package com.ruoyi.service.impl;

import com.ruoyi.service.AllFileService;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ooxml.POIXMLException;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.*;
import org.springframework.stereotype.Service;

import java.io.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * @Author:zzm
 * @Date: 2024/12/10 15:25
 */
@Service
public class AllFileServiceImpl implements AllFileService {

    /**
     * 数据1,2处理
     * 修改excel表名并修改指定日期区间
     */
    @Override
    public void allFile() {
        System.out.println("--------------------------开始-------处理表名-----------------------------");
        String path = "\\\\192.168.10.30\\共享\\对账单";
        File folder = new File(path);

        // 获取文件夹下所有.xlsx文件，并进行遍历处理
        File[] files = folder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        if (files != null) {
            // 使用当前日期作为目标日期
            LocalDate currentDate = LocalDate.now();
            // 设置目标日期为当前月
            LocalDate targetDate = currentDate;

            // 获取目标月份的第一天和最后一天
            LocalDate firstDayOfTargetMonth = targetDate.withDayOfMonth(1);
            LocalDate lastDayOfTargetMonth = firstDayOfTargetMonth.withDayOfMonth(firstDayOfTargetMonth.lengthOfMonth());

            // 格式化日期
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
            // 输出目标月份的日期范围
            String dateRange = firstDayOfTargetMonth.format(formatter) + " - " + lastDayOfTargetMonth.format(formatter);

            for (File file : files) {
                try {
                    // 修改Excel文件内容
                    try (FileInputStream fis = new FileInputStream(file);
                         XSSFWorkbook workbook = new XSSFWorkbook(fis)) {
                        Sheet sheet = workbook.getSheetAt(0);  // 假设是第一个sheet
                        Row row = sheet.getRow(2);  // 第3行（行索引是2）
                        if (row == null) {
                            row = sheet.createRow(2);
                        }
                        Cell cell = row.getCell(3);  // D列（列索引是3）
                        if (cell == null) {
                            cell = row.createCell(3);
                        }

                        // 修改单元格内容
                        cell.setCellValue(dateRange);

                        // 保存文件
                        try (FileOutputStream fos = new FileOutputStream(file)) {
                            workbook.write(fos);
                        }

                        System.out.println("文件 " + file.getName() + " 修改完成");
                    } catch (Exception e) {
                        System.err.println("无法处理 Excel 文件: " + file.getName());
                        e.printStackTrace();
                    }

                    // 获取文件路径和文件名
                    String oldPathName = file.getPath();
                    System.out.println("原文件名：" + oldPathName);  // 输出原文件名，方便调试

                    if (oldPathName.endsWith(".xlsx")) {
                        // 格式化目标日期（例如：2024年10月）
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月");
                        String newDateStr = sdf.format(java.sql.Date.valueOf(targetDate));

                        // 检查新的日期格式是否正确
                        System.out.println("格式化后的目标日期: " + newDateStr);

                        // 1. 拆分文件路径
                        String[] pathParts = oldPathName.split("-");  // 按照 "-" 分割路径

                        // 输出拆分结果，调试
                        System.out.println("拆分后的文件名部分：");
                        for (String part : pathParts) {
                            System.out.println(part);
                        }

                        // 2. 处理日期部分替换
                        if (pathParts.length > 1) {
                            // 替换第二部分（日期部分）
                            pathParts[1] = newDateStr;  // 替换中间的日期部分
                            String newFileName;
                            if (file.getName().contains("易仓")) {
                                // 3. 拼接新的文件名
                                newFileName = pathParts[0] + "-" + pathParts[1] + "对账单-易仓.xlsx";
                            } else {
                                newFileName = pathParts[0] + "-" + pathParts[1] + "对账单.xlsx";
                            }


                            // 输出新的文件名
                            System.out.println("新的文件名：" + newFileName);

                            // 重命名文件
                            file.renameTo(new File(newFileName));
                        } else {
                            System.err.println("文件名拆分失败，无法替换日期：" + oldPathName);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } else {
            System.out.println("没有找到 Excel 文件！");
        }
        System.out.println("--------------------------结束-------处理表名-----------------------------");

    }

    @Override
    public void agentMerge() {
        System.out.println("--------------------------开始-------处理物流费用-----------------------------");
        //String folderPath = "D:\\caiwu\\物流明细";  // 替换为你的文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\物流明细";
        String outputFilePath = folderPath + "/物流明细汇总文件.xlsx";  // 输出的汇总Excel文件路径
        //DecimalFormat df = new DecimalFormat("#.00");  // 保留两位小数的格式化对象

        try {
            // 创建一个新的工作簿，用于保存汇总结果
            Workbook mergedWorkbook = new XSSFWorkbook();
            Sheet mergedSheet = mergedWorkbook.createSheet("出库订单");
            Sheet mergedSheet2 = mergedWorkbook.createSheet("运费补收");
            Sheet mergedSheet3 = mergedWorkbook.createSheet("购买运单");
            Sheet mergedSheet4 = mergedWorkbook.createSheet("其它费用");

            // 获取文件夹中的所有Excel文件
            File folder = new File(folderPath);
            File[] excelFiles = folder.listFiles((dir, name) -> name.endsWith(".xlsx") || name.endsWith(".xls"));
            // 用于存储表头
            List<String> headers = new ArrayList<>();
            int rowNum = 0, rowNum2 = 0, rowNum3 = 0, rowNum4 = 0;  // 用于分别记录三个sheet的行号

            // 创建字体对象并设置字体为"等线"（Microsoft YaHei）且字号为10
            XSSFFont font = (XSSFFont) mergedWorkbook.createFont();
            font.setFontName("等线");  // 设置字体为等线
            font.setFontHeightInPoints((short) 10);  // 设置字号为10

            // 创建单元格样式对象并应用字体
            CellStyle cellStyle = mergedWorkbook.createCellStyle();
            cellStyle.setFont(font);

            for (File excelFile : excelFiles) {
                String lastName = null;
                if (!excelFile.getName().contains("汇总文件")) {
                    lastName = excelFile.getName().substring(28, 32);
                }
                FileInputStream fis = new FileInputStream(excelFile);

                // 判断文件扩展名，根据文件类型选择对应的POI类
                Workbook workbook;
                if (excelFile.getName().endsWith(".xlsx")) {
                    workbook = new XSSFWorkbook(fis);  // 处理.xlsx格式的文件
                } else if (excelFile.getName().endsWith(".xls")) {
                    workbook = new HSSFWorkbook(fis);  // 处理.xls格式的文件
                } else {
                    fis.close();
                    continue;  // 忽略非Excel文件
                }

                // 处理第一个sheet（出库订单）
                Sheet sheet = workbook.getSheetAt(0);
                // 如果是第一次处理文件，记录表头
                if (rowNum == 0) {
                    Row headerRow = sheet.getRow(0);  // 假设表头在第一行
                    for (Cell cell : headerRow) {
                        headers.add(cell.getStringCellValue());
                    }

                    // 将表头写入汇总文件
                    Row headerMergedRow = mergedSheet.createRow(rowNum++);
                    for (int i = 0; i < headers.size(); i++) {
                        Cell headerCell = headerMergedRow.createCell(i);
                        headerCell.setCellValue(headers.get(i));
                        headerCell.setCellStyle(cellStyle);  // 应用字体样式
                    }
                    // 添加表名列
                    headerMergedRow.createCell(headers.size()).setCellValue("客户编码");
                }

                // 读取每个sheet的数据并写入汇总文件
                for (int i = 1; i <= sheet.getLastRowNum(); i++) {  // 从第二行开始读取数据
                    Row row = sheet.getRow(i);
                    if (row != null) {
                        Row mergedRow = mergedSheet.createRow(rowNum++);
                        for (int j = 0; j < headers.size(); j++) {
                            Cell cell = row.getCell(j);
                            if (cell != null) {
                                if (j == 11 || j == 12 || j == 13 || j == 14 || j == 15 || j == 17 || j == 30 || j == 31 || j == 33) { // 特定列（索引从0开始）
                                    if (j == 14) { // j=14时的特殊处理
                                        if (cell.getCellType() == CellType.STRING) {
                                            String cellValue = cell.getStringCellValue();
                                            try {
                                                // 转为BigDecimal并去掉小数
                                                BigDecimal value = new BigDecimal(cellValue).setScale(0, RoundingMode.HALF_UP);
                                                Cell mergedCell = mergedRow.createCell(j);
                                                mergedCell.setCellValue(value.doubleValue()); // 设置为BigDecimal类型，不保留小数
                                                mergedCell.setCellStyle(cellStyle); // 应用字体样式
                                            } catch (NumberFormatException e) {
                                                // 如果转换失败，填充0或其他默认值
                                                mergedRow.createCell(j).setCellValue(0);
                                            }
                                        } else {
                                            // 非字符串类型的处理
                                            mergedRow.createCell(j).setCellValue(0);
                                        }
                                    } else {
                                        if (cell.getCellType() == CellType.NUMERIC) {
                                            BigDecimal value = BigDecimal.valueOf(cell.getNumericCellValue());
                                            Cell mergedCell = mergedRow.createCell(j);
                                            mergedCell.setCellValue(value.setScale(2, RoundingMode.HALF_UP).doubleValue()); // 保留两位小数
                                            mergedCell.setCellStyle(cellStyle); // 应用字体样式
                                        } else {
                                            mergedRow.createCell(j).setCellValue(0); // 非数字填充0
                                        }
                                    }
                                } else {
                                    Cell mergedCell = mergedRow.createCell(j);
                                    mergedCell.setCellValue(cell.toString());
                                    mergedCell.setCellStyle(cellStyle); // 应用字体样式
                                }
                            }
                        }
                        mergedRow.createCell(headers.size()).setCellValue(lastName); // 添加表名列
                    }
                }

                // 处理第三个sheet（根据内容拆分）
                Sheet thirdSheet = workbook.getSheetAt(2);
                // 获取第三个Sheet的表头
                Row thirdSheetHeaderRow = thirdSheet.getRow(0);
                List<String> thirdSheetHeaders = new ArrayList<>();
                if (thirdSheetHeaderRow != null) {
                    for (Cell cell : thirdSheetHeaderRow) {
                        thirdSheetHeaders.add(cell.getStringCellValue());
                    }
                }

                // 将第三个Sheet的表头添加到“运费补收”和“购买运单”两个Sheet中
                if (rowNum2 == 0 && !thirdSheetHeaders.isEmpty()) {
                    Row headerMergedRow2 = mergedSheet2.createRow(rowNum2++);
                    for (int i = 0; i < thirdSheetHeaders.size(); i++) {
                        headerMergedRow2.createCell(i).setCellValue(thirdSheetHeaders.get(i));
                        headerMergedRow2.getCell(i).setCellStyle(cellStyle);  // 应用字体样式
                    }
                    // 添加表名列
                    headerMergedRow2.createCell(thirdSheetHeaders.size()).setCellValue("客户编码");
                }
                if (rowNum3 == 0 && !thirdSheetHeaders.isEmpty()) {
                    Row headerMergedRow3 = mergedSheet3.createRow(rowNum3++);
                    for (int i = 0; i < thirdSheetHeaders.size(); i++) {
                        headerMergedRow3.createCell(i).setCellValue(thirdSheetHeaders.get(i));
                        headerMergedRow3.getCell(i).setCellStyle(cellStyle);  // 应用字体样式
                    }
                    // 添加表名列
                    headerMergedRow3.createCell(thirdSheetHeaders.size()).setCellValue("客户编码");
                }

                if (rowNum4 == 0 && !thirdSheetHeaders.isEmpty()) {
                    Row headerMergedRow4 = mergedSheet4.createRow(rowNum4++);
                    for (int i = 0; i < thirdSheetHeaders.size(); i++) {
                        headerMergedRow4.createCell(i).setCellValue(thirdSheetHeaders.get(i));
                        headerMergedRow4.getCell(i).setCellStyle(cellStyle);  // 应用字体样式
                    }
                    // 添加表名列
                    headerMergedRow4.createCell(thirdSheetHeaders.size()).setCellValue("客户编码");
                }

                // 处理第三个Sheet的数据，并根据条件分流
                for (int i = 1; i <= thirdSheet.getLastRowNum(); i++) {  // 从第二行开始读取数据
                    Row row = thirdSheet.getRow(i);
                    if (row != null) {
                        String thirdColumnValue = row.getCell(2) != null ? row.getCell(2).toString() : ""; // 获取第三列数据

                        if (thirdColumnValue.contains("运费补收")) {
                            Row mergedRow = mergedSheet2.createRow(rowNum2++);
                            for (int j = 0; j < thirdSheetHeaders.size(); j++) {
                                Cell cell = row.getCell(j);
                                if (cell != null) {
                                    if (j == 4) { // 第5列（索引从0开始）
                                        try {
                                            if (cell.getCellType() == CellType.NUMERIC) {
                                                BigDecimal value = BigDecimal.valueOf(cell.getNumericCellValue());
                                                Cell mergedCell = mergedRow.createCell(j);
                                                mergedCell.setCellValue(value.setScale(2, RoundingMode.HALF_UP).doubleValue()); // 设置为数字类型
                                                mergedCell.setCellStyle(cellStyle);  // 应用字体样式
                                            } else {
                                                mergedRow.createCell(j).setCellValue(0); // 非数字填充0
                                            }
                                        } catch (Exception e) {
                                            mergedRow.createCell(j).setCellValue(0); // 异常处理
                                        }
                                    } else {
                                        Cell mergedCell = mergedRow.createCell(j);
                                        mergedCell.setCellValue(cell.toString());
                                        mergedCell.setCellStyle(cellStyle);  // 应用字体样式
                                    }
                                }
                            }
                            mergedRow.createCell(thirdSheetHeaders.size()).setCellValue(lastName);
                        } else if (thirdColumnValue.contains("购买运单")) {
                            Row mergedRow = mergedSheet3.createRow(rowNum3++);
                            for (int j = 0; j < thirdSheetHeaders.size(); j++) {
                                Cell cell = row.getCell(j);
                                if (cell != null) {
                                    if (j == 4) { // 第5列（索引从0开始）
                                        try {
                                            if (cell.getCellType() == CellType.NUMERIC) {
                                                BigDecimal value = BigDecimal.valueOf(cell.getNumericCellValue());
                                                Cell mergedCell = mergedRow.createCell(j);
                                                mergedCell.setCellValue(value.setScale(2, RoundingMode.HALF_UP).doubleValue()); // 设置为数字类型
                                                mergedCell.setCellStyle(cellStyle);  // 应用字体样式
                                            } else {
                                                mergedRow.createCell(j).setCellValue(0); // 非数字填充0
                                            }
                                        } catch (Exception e) {
                                            mergedRow.createCell(j).setCellValue(0); // 异常处理
                                        }
                                    } else {
                                        Cell mergedCell = mergedRow.createCell(j);
                                        mergedCell.setCellValue(cell.toString());
                                        mergedCell.setCellStyle(cellStyle);  // 应用字体样式
                                    }
                                }
                            }
                            mergedRow.createCell(thirdSheetHeaders.size()).setCellValue(lastName);
                        } else if (thirdColumnValue.contains("其它费用")) {
                            String sixthColumnValue = row.getCell(5) != null ? row.getCell(5).toString() : "";

                            // 如果第6列包含"ABC"，则跳过该行，不进行写入
                            if (sixthColumnValue.contains("扣款") || sixthColumnValue.contains("到账")) {
                                continue; // 跳过当前行
                            }
                            Row mergedRow = mergedSheet4.createRow(rowNum4++);
                            for (int j = 0; j < thirdSheetHeaders.size(); j++) {
                                Cell cell = row.getCell(j);
                                if (cell != null) {
                                    if (j == 4) { // 第5列（索引从0开始）
                                        try {
                                            if (cell.getCellType() == CellType.NUMERIC) {
                                                BigDecimal value = BigDecimal.valueOf(cell.getNumericCellValue());
                                                Cell mergedCell = mergedRow.createCell(j);
                                                mergedCell.setCellValue(value.setScale(2, RoundingMode.HALF_UP).doubleValue()); // 设置为数字类型
                                                mergedCell.setCellStyle(cellStyle);  // 应用字体样式
                                            } else {
                                                mergedRow.createCell(j).setCellValue(0); // 非数字填充0
                                            }
                                        } catch (Exception e) {
                                            mergedRow.createCell(j).setCellValue(0); // 异常处理
                                        }
                                    } else {
                                        Cell mergedCell = mergedRow.createCell(j);
                                        mergedCell.setCellValue(cell.toString());
                                        mergedCell.setCellStyle(cellStyle);  // 应用字体样式
                                    }
                                }
                            }
                            mergedRow.createCell(thirdSheetHeaders.size()).setCellValue(lastName);
                        }
                    }
                }


                workbook.close();
                fis.close();
            }

            // 保存汇总的Excel文件
            FileOutputStream fos = new FileOutputStream(outputFilePath);
            mergedWorkbook.write(fos);
            fos.close();
            mergedWorkbook.close();

            System.out.println("Excel文件合并完成，输出文件：" + outputFilePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("--------------------------结束-------处理物流费用-----------------------------");
    }

    @Override
    public void otherChannel() {
        System.out.println("--------------------------开始-------处理其他渠道-----------------------------");
//        String folderPath = "D:/caiwu/渠道明细";  // 文件夹路径
//        String sourceFolderPath = "D:/caiwu/汇总文件";  // 文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\渠道明细";  // 替换为你的文件夹路径
        String outputFilePath = folderPath + "/渠道明细汇总文件.xlsx";  // 输出的汇总Excel文件路径

        try {
            // 创建一个新的工作簿，用于保存汇总结果
            Workbook mergedWorkbook = new XSSFWorkbook();
            Sheet mergedSheet = mergedWorkbook.createSheet("出库订单");

            // 获取文件夹中的所有Excel文件
            File folder = new File(folderPath);
            File[] excelFiles = folder.listFiles((dir, name) -> name.endsWith(".xlsx") || name.endsWith(".xls"));

            // 用于存储表头
            List<String> headers = new ArrayList<>();
            int rowNum = 0;

            // 创建字体对象并设置字体为"等线"（Microsoft YaHei）且字号为10
            XSSFFont font = (XSSFFont) mergedWorkbook.createFont();
            font.setFontName("等线");  // 设置字体为等线
            font.setFontHeightInPoints((short) 10);  // 设置字号为10

            // 创建单元格样式对象并应用字体
            CellStyle cellStyle = mergedWorkbook.createCellStyle();
            cellStyle.setFont(font);

            // 为需要保留三位小数的列（27, 28, 29）创建单独的样式
            CellStyle decimalStyle = mergedWorkbook.createCellStyle();
            DataFormat dataFormat = mergedWorkbook.createDataFormat();
            decimalStyle.setDataFormat(dataFormat.getFormat("0.000"));  // 显示三位小数
            decimalStyle.setFont(font);  // 复制字体样式

            // 为需要保留三位小数的列（25）创建单独的样式
            CellStyle decimalStyle25 = mergedWorkbook.createCellStyle();
            DataFormat dataFormat25 = mergedWorkbook.createDataFormat();
            decimalStyle25.setDataFormat(dataFormat25.getFormat("0.0"));  // 显示三位小数
            decimalStyle25.setFont(font);  // 复制字体样式


            // 默认样式，用于其他列
            CellStyle defaultCellStyle = mergedWorkbook.createCellStyle();
            defaultCellStyle.setFont(font);

            for (File excelFile : excelFiles) {
                FileInputStream fis = new FileInputStream(excelFile);

                // 判断文件扩展名，根据文件类型选择对应的POI类
                Workbook workbook;
                if (excelFile.getName().endsWith(".xlsx")) {
                    workbook = new XSSFWorkbook(fis);  // 处理.xlsx格式的文件
                } else if (excelFile.getName().endsWith(".xls")) {
                    workbook = new HSSFWorkbook(fis);  // 处理.xls格式的文件
                } else {
                    fis.close();
                    continue;  // 忽略非Excel文件
                }

                Sheet sheet = workbook.getSheetAt(0);  // 获取第一个sheet

                // 如果是第一次处理文件，记录表头
                if (rowNum == 0) {
                    Row headerRow = sheet.getRow(0);  // 假设表头在第一行
                    for (Cell cell : headerRow) {
                        headers.add(cell.getStringCellValue());
                    }

                    // 将表头写入汇总文件
                    Row headerMergedRow = mergedSheet.createRow(rowNum++);
                    for (int i = 0; i < headers.size(); i++) {
                        Cell headerCell = headerMergedRow.createCell(i);
                        headerCell.setCellValue(headers.get(i));
                        headerCell.setCellStyle(cellStyle);  // 应用字体样式
                    }
                }

                // 读取每个sheet的数据并写入汇总文件
                for (int i = 1; i <= sheet.getLastRowNum(); i++) {  // 从第二行开始读取数据
                    Row row = sheet.getRow(i);
                    if (row != null) {
                        Row mergedRow = mergedSheet.createRow(rowNum++);
                        // 复制每列数据
                        for (int j = 0; j < headers.size(); j++) {
                            Cell cell = row.getCell(j);
                            if (cell != null) {
                                // 创建目标单元格
                                Cell mergedCell = mergedRow.createCell(j);

                                // 特殊列的处理
                                if (j == 25) { // j=25时保留一位小数
                                    String cellValue = cell.toString().trim();  // 获取单元格内容并去除前后空格
                                    double value = 0;  // 默认值

                                    // 尝试将字符串转换为数字
                                    try {
                                        value = Double.parseDouble(cellValue);
                                    } catch (NumberFormatException e) {
                                        // 如果转换失败，则值为0
                                        value = 0;
                                    }

                                    // 使用BigDecimal设置三位小数
                                    BigDecimal bigValue = BigDecimal.valueOf(value).setScale(1, RoundingMode.HALF_UP);
                                    double finalValue = bigValue.doubleValue();  // 获取最终数值

                                    // 设置目标单元格的值
                                    mergedCell.setCellValue(finalValue);

                                    // 应用三位小数格式
                                    mergedCell.setCellStyle(decimalStyle25);  // 只对特定列设置三位小数样式
                                } else if (j == 27 || j == 28 || j == 29) {  // j=27,28,29列保留三位小数
                                    String cellValue = cell.toString().trim();  // 获取单元格内容并去除前后空格
                                    double value = 0;  // 默认值

                                    // 尝试将字符串转换为数字
                                    try {
                                        value = Double.parseDouble(cellValue);
                                    } catch (NumberFormatException e) {
                                        // 如果转换失败，则值为0
                                        value = 0;
                                    }

                                    // 使用BigDecimal设置三位小数
                                    BigDecimal bigValue = BigDecimal.valueOf(value).setScale(3, RoundingMode.HALF_UP);
                                    double finalValue = bigValue.doubleValue();  // 获取最终数值

                                    // 设置目标单元格的值
                                    mergedCell.setCellValue(finalValue);

                                    // 应用三位小数格式
                                    mergedCell.setCellStyle(decimalStyle);  // 只对特定列设置三位小数样式
                                } else if (j == 30) { // j=30转为数值并×1000，不保留小数
                                    String cellValue = cell.toString().trim();  // 获取单元格内容并去除前后空格
                                    double value = 0;  // 默认值

                                    // 尝试将字符串转换为数字
                                    try {
                                        value = Double.parseDouble(cellValue);  // 将值解析为数字
                                    } catch (NumberFormatException e) {
                                        value = 0;  // 如果转换失败，值设为0
                                    }

                                    // 将值乘以1000
                                    BigDecimal bigValue = BigDecimal.valueOf(value).multiply(BigDecimal.valueOf(1000)).setScale(0, RoundingMode.HALF_UP);

                                    // 设置目标单元格的值
                                    mergedCell.setCellValue(bigValue.doubleValue());

                                    // 应用默认样式（无小数）
                                    mergedCell.setCellStyle(defaultCellStyle);  // 保持默认样式
                                } else if (j == 36) { // j=36时保留2位小数
                                    double value = getNumericValue(cell);
                                    if (value != -1) { // 如果转换成功
                                        BigDecimal bigValue = BigDecimal.valueOf(value).setScale(2, RoundingMode.HALF_UP);
                                        mergedCell.setCellValue(bigValue.doubleValue());
                                    } else {
                                        mergedCell.setCellValue(0); // 非数字填充0
                                    }
                                    mergedCell.setCellStyle(defaultCellStyle);  // 保持默认样式
                                } else { // 其他列直接复制
                                    mergedCell.setCellValue(cell.toString());
                                    mergedCell.setCellStyle(defaultCellStyle);  // 保持默认样式
                                }
                            }
                        }
                    }
                }
                workbook.close();
                fis.close();
            }

            // 保存汇总的Excel文件
            FileOutputStream fos = new FileOutputStream(outputFilePath);
            mergedWorkbook.write(fos);
            fos.close();
            mergedWorkbook.close();

            System.out.println("Excel文件合并完成，输出文件：" + outputFilePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("--------------------------结束-------处理其他渠道-----------------------------");

    }

    // 辅助方法：将单元格的值转为数字，处理字符串和数字类型
    private double getNumericValue(Cell cell) {
        if (cell.getCellType() == CellType.NUMERIC) {
            return cell.getNumericCellValue();
        } else if (cell.getCellType() == CellType.STRING) {
            try {
                // 如果是字符串类型，尝试将其转换为数字
                return Double.parseDouble(cell.getStringCellValue().trim());
            } catch (NumberFormatException e) {
                return -1;  // 如果转换失败，返回-1表示无效
            }
        }
        return -1; // 如果是其他类型，返回-1
    }

    @Override
    public void allToDetail() {
        System.out.println("--------------------------开始-------处理汇总写入对账单-----------------------------");
        System.out.println(new Date());

//        String folderPath = "D:/caiwu/对账单";  // 文件夹路径
//        String sourceFolderPath = "D:/caiwu/汇总文件";  // 文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\对账单";  // 存放目标文件的文件夹路径
        String sourceFolderPath = "\\\\192.168.10.30\\共享\\汇总文件";  // 源Excel文件夹路径
        String unmatchedLogPath = "\\\\192.168.10.30\\共享\\未匹配客户\\汇总写入对账单未匹配客户编码.txt";  // 记录未匹配客户编码的路径

        // 获取源文件夹中的所有Excel文件
        File sourceFolder = new File(sourceFolderPath);
        File[] sourceFiles = sourceFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        File unmatchedLogFile = new File(unmatchedLogPath);

        // 获取对账单文件夹中的Excel文件
        File billFolder = new File(folderPath);
        File[] billFiles = billFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        // 为每个目标文件批量收集要写入的数据
        Map<File, List<Row>> dataToWrite = new HashMap<>();
        Set<String> unmatchedCustomerCodes = new HashSet<>(); // 用于存储未匹配的客户编码
        // 处理每个源文件
        for (File sourceFile : sourceFiles) {
            try (FileInputStream fis = new FileInputStream(sourceFile);
                 XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

                // 读取第一个Sheet
                for (int sheetIndex = 0; sheetIndex < 2; sheetIndex++) {  // 只读取前两个Sheet
                    Sheet sheet = workbook.getSheetAt(sheetIndex);
                    // 从第三行开始读取数据
                    for (int i = 2; i < sheet.getPhysicalNumberOfRows(); i++) {  // 从第三行开始（索引从0开始）
                        Row row = sheet.getRow(i);
                        if (row == null) continue;  // 跳过空行

                        // 获取最后一列（客户编码）
                        Cell cell = row.getCell(row.getLastCellNum() - 1);
                        if (cell == null) continue;  // 如果最后一列为空，跳过当前行

                        String customerCode = cell.getStringCellValue().trim();
                        System.out.println("正在处理客户编码: " + customerCode);
                        boolean matched = false; // 标志是否匹配到目标文件

                        for (File caiwuFile : billFiles) {
                            String caiwuFileName = caiwuFile.getName();

                            // 排除包含“易仓”和“效合”的文件
                            if (caiwuFileName.contains("易仓") || caiwuFileName.contains("效合")) {
                                continue;
                            }

                            // 检查文件名的前四位是否匹配客户编码
                            if (caiwuFileName.substring(0, 4).equals(customerCode)) {
                                matched = true;
                                // 如果匹配，将数据添加到目标文件的列表中
                                dataToWrite
                                        .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                        .add(row);
                            }
                        }

                        if (!matched) {
                            unmatchedCustomerCodes.add(customerCode); // 添加未匹配的客户编码
                        }

                    }
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 批量写入数据
        for (Map.Entry<File, List<Row>> entry : dataToWrite.entrySet()) {
            File caiwuFile = entry.getKey();
            List<Row> rowsToWrite = entry.getValue();
            writeDataToFile(caiwuFile, rowsToWrite);
        }
        // 将未匹配的客户编码写入记事本
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(unmatchedLogFile, true))) {
            // 添加当前时间
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            String timestamp = LocalDateTime.now().format(formatter);
            writer.write("时间: " + timestamp);
            writer.newLine();
            for (String code : unmatchedCustomerCodes) {
                writer.write(code);
                writer.newLine();
            }
            System.out.println("未匹配的客户编码已写入文件: " + unmatchedLogPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
        System.out.println("--------------------------结束-------处理汇总写入对账单-----------------------------");
    }

    private static void writeDataToFile(File caiwuFile, List<Row> sourceRows) {
        try (FileInputStream fis = new FileInputStream(caiwuFile);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(1);
            System.out.println("目标Sheet名称: " + sheet.getSheetName());

            // 创建基础样式
            XSSFFont font = workbook.createFont();
            font.setFontName("等线");
            font.setFontHeightInPoints((short) 10);

            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font);

            XSSFCellStyle numberCellStyle = workbook.createCellStyle();
            numberCellStyle.setFont(font);
            numberCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0.00"));

            XSSFCellStyle integerCellStyle = workbook.createCellStyle();
            integerCellStyle.setFont(font);
            integerCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0"));

            // 日期时间格式 yyyy/MM/dd HH:mm:ss
            XSSFCellStyle dateTimeCellStyle = workbook.createCellStyle();
            dateTimeCellStyle.setFont(font);
            dateTimeCellStyle.setDataFormat(workbook.createDataFormat().getFormat("yyyy/MM/dd HH:mm:ss"));

            int targetRowIndex = 2; // 从第三行开始写入

            // 批量写入数据
            for (Row sourceRow : sourceRows) {
                Row targetRow = sheet.createRow(targetRowIndex++);

                for (int i = 0; i < sourceRow.getLastCellNum(); i++) {
                    if (i == sourceRow.getLastCellNum() - 1) continue; // 跳过客户编码列

                    Cell sourceCell = sourceRow.getCell(i);
                    Cell targetCell = targetRow.createCell(i);

                    if (sourceCell == null) {
                        targetCell.setCellValue("");
                        targetCell.setCellStyle(cellStyle);
                        continue;
                    }

                    // 设置样式：先默认赋值，后面可能覆盖
                    targetCell.setCellStyle(cellStyle);

                    switch (sourceCell.getCellType()) {
                        case STRING:
                            targetCell.setCellValue(sourceCell.getStringCellValue());
                            break;

                        case NUMERIC:
                            if (DateUtil.isCellDateFormatted(sourceCell)) {
                                // 处理日期时间
                                targetCell.setCellValue(sourceCell.getDateCellValue());
                                targetCell.setCellStyle(dateTimeCellStyle);
                            } else {
                                double numericValue = sourceCell.getNumericCellValue();
                                if ((i >= 12 && i < 17) || (i >= 32 && i <= 55)) {
                                    targetCell.setCellValue(numericValue);
                                    targetCell.setCellStyle(numberCellStyle);
                                } else if (i == 11 || i == 17 || i == 19) {
                                    targetCell.setCellValue((long) numericValue);
                                    targetCell.setCellStyle(integerCellStyle);
                                } else {
                                    targetCell.setCellValue(numericValue);
                                }
                            }
                            break;

                        case FORMULA:
                            switch (sourceCell.getCachedFormulaResultType()) {
                                case NUMERIC:
                                    if (DateUtil.isCellDateFormatted(sourceCell)) {
                                        targetCell.setCellValue(sourceCell.getDateCellValue());
                                        targetCell.setCellStyle(dateTimeCellStyle);
                                    } else {
                                        double formulaValue = sourceCell.getNumericCellValue();
                                        if ((i >= 12 && i < 17) || (i >= 32 && i <= 55)) {
                                            targetCell.setCellValue(formulaValue);
                                            targetCell.setCellStyle(numberCellStyle);
                                        } else if (i == 11 || i == 17 || i == 19) {
                                            targetCell.setCellValue((long) formulaValue);
                                            targetCell.setCellStyle(integerCellStyle);
                                        } else {
                                            targetCell.setCellValue(formulaValue);
                                        }
                                    }
                                    break;
                                case STRING:
                                    targetCell.setCellValue(sourceCell.getStringCellValue());
                                    break;
                                default:
                                    targetCell.setCellValue("");
                            }
                            break;

                        default:
                            targetCell.setCellValue("");
                    }
                }
            }

            // 强制公式重新计算
            workbook.setForceFormulaRecalculation(true);

            try (FileOutputStream fos = new FileOutputStream(caiwuFile)) {
                workbook.write(fos);
                System.out.println("数据已写入文件: " + caiwuFile.getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    // 辅助方法：处理数字单元格（提取重复逻辑）
    private static void handleNumericCell(Cell sourceCell, Cell targetCell, int scale) {
        try {
            double value;
            if (sourceCell.getCellType() == CellType.STRING) {
                value = new BigDecimal(sourceCell.getStringCellValue().trim()).doubleValue();
            } else {
                value = sourceCell.getNumericCellValue();
            }

            if (scale == 0) {
                targetCell.setCellValue((long) value); // 整数
            } else {
                targetCell.setCellValue(new BigDecimal(value).setScale(scale, RoundingMode.HALF_UP).doubleValue());
            }
        } catch (Exception e) {
            targetCell.setCellValue(0); // 异常时填充0
        }
    }

    @Override
    public void delete() {
        File folder = new File("D:/caiwu/12"); // 指定文件夹路径
        File[] files = folder.listFiles((dir, name) -> name.endsWith(".xlsx") && !name.contains("效合") && !name.contains("易仓"));

        if (files != null) {
            for (File file : files) {
                try {
                    processFile(file);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("删除成功");
    }

    @Override
    public void colour() {
        // 设置目标文件夹路径
        String folderPath = "D:/caiwu/另外9个";  // 替换为你的文件夹路径
        File folder = new File(folderPath);

        // 获取所有 Excel 文件
        File[] files = folder.listFiles((dir, name) -> name.endsWith(".xlsx") || name.endsWith(".xlsm"));

        if (files != null) {
            for (File file : files) {
                try (FileInputStream fis = new FileInputStream(file)) {
                    // 打开 Excel 文件
                    Workbook workbook = new XSSFWorkbook(fis);

                    // 检查是否有足够的 Sheet
                    if (workbook.getNumberOfSheets() >= 3) {
                        // 获取第三个 Sheet
                        Sheet sheet = workbook.getSheetAt(2);

                        // 确保第 1 行存在
                        Row row = sheet.getRow(0);
                        if (row == null) {
                            row = sheet.createRow(0);
                        }

                        // 确保 O1 和 P1 单元格存在
                        Cell o1Cell = row.getCell(14); // O 列（索引 14）
                        if (o1Cell == null) {
                            o1Cell = row.createCell(14);
                        }

                        Cell p1Cell = row.getCell(15); // P 列（索引 15）
                        if (p1Cell == null) {
                            p1Cell = row.createCell(15);
                        }

                        // 创建一个新的 CellStyle
                        CellStyle style = workbook.createCellStyle();

                        // 设置背景颜色为灰色
                        style.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
                        style.setFillPattern(FillPatternType.SOLID_FOREGROUND);

                        // 创建字体样式，设置为等线字体，大小为10
                        Font font = workbook.createFont();
                        font.setFontName("等线"); // 设置字体为等线
                        font.setFontHeightInPoints((short) 10); // 字号10
                        style.setFont(font);

                        // 应用样式到单元格
                        o1Cell.setCellStyle(style);
                        p1Cell.setCellStyle(style);

                        // 设置列宽（单位为字符宽度的1/256）
                        sheet.setColumnWidth(14, 18 * 256); // O列
                        sheet.setColumnWidth(15, 18 * 256); // P列

                        // 输出日志
                        System.out.println("修改文件: " + file.getName());
                    }

                    // 保存修改后的文件
                    try (FileOutputStream fos = new FileOutputStream(file)) {
                        workbook.write(fos);
                    }

                    // 关闭工作簿
                    workbook.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } else {
            System.out.println("目标文件夹中没有找到 Excel 文件！");

        }
    }

    public static void processFile(File file) throws IOException {
        try (FileInputStream fis = new FileInputStream(file);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            // 获取第二个Sheet
            System.out.println(file.getName());
            Sheet sheet = workbook.getSheetAt(6);

            // 从第3行开始删除所有行
            int lastRowNum = sheet.getLastRowNum();
            for (int i = lastRowNum; i >= 1; i--) { // 从第3行（索引为2）开始
                Row row = sheet.getRow(i);
                if (row != null) {
                    sheet.removeRow(row); // 删除该行
                }
            }

            // 保存修改后的文件
            try (FileOutputStream fos = new FileOutputStream(file)) {
                workbook.write(fos);
            }
        }
    }

    /**
     * 运费补收
     *
     * @throws IOException
     */
    @Override
    public void freightSurcharge() throws IOException {
        System.out.println("--------------------------开始-------处理运费补收-----------------------------");
        System.out.println(new Date());
//        String folderPath = "D:/caiwu/对账单";  // 文件夹路径
//        String sourceFolderPath = "D:/caiwu/运费补收";  // 文件夹路径
        String sourceFolderPath = "\\\\192.168.10.30\\共享\\运费补收";  // 源文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\对账单";  // 目标文件夹路径
        String unmatchedLogPath = "\\\\192.168.10.30\\共享\\未匹配客户\\运费补收未匹配客户编码.txt";  // 记录未匹配客户编码的路径

        // 获取源文件夹中的所有Excel文件
        File sourceFolder = new File(sourceFolderPath);
        File[] sourceFiles = sourceFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        // 创建记录未匹配客户编码的文件
        File unmatchedLogFile = new File(unmatchedLogPath);

        // 获取目标文件夹中的所有Excel文件
        File billFolder = new File(folderPath);
        File[] billFiles = billFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        // 为每个目标文件批量收集要写入的数据
        Map<File, List<Row>> dataToWrite = new HashMap<>();
        Set<String> unmatchedCustomerCodes = new HashSet<>(); // 用于存储未匹配的客户编码

        // 处理每个源文件
        for (File sourceFile : sourceFiles) {
            try (FileInputStream fis = new FileInputStream(sourceFile);
                 XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

                // 读取第一个Sheet
                Sheet sheet = workbook.getSheetAt(0);
                // 从第4行开始读取数据
                for (int i = 3; i < sheet.getPhysicalNumberOfRows(); i++) {  // 从第4行开始（索引从0开始）
                    Row row = sheet.getRow(i);
                    if (row == null) continue;  // 跳过空行

                    Cell cell = row.getCell(0);
                    if (cell == null) continue;  // 如果最后一列为空，跳过当前行

                    String customerCode = cell.getStringCellValue().trim();
                    System.out.println("正在处理客户编码: " + customerCode);
                    boolean matched = false; // 标志是否匹配到目标文件

                    for (File caiwuFile : billFiles) {
                        String caiwuFileName = caiwuFile.getName();

                        // 排除包含“易仓”和“效合”的文件
                        if (caiwuFileName.contains("易仓") || caiwuFileName.contains("效合")) {
                            continue;
                        }

                        // 检查文件名的前四位是否匹配客户编码
                        if (caiwuFileName.substring(0, 4).equals(customerCode)) {
                            // 如果匹配，将数据添加到目标文件的列表中
                            matched = true;
                            dataToWrite
                                    .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                    .add(row);
                        }
                    }

                    if (!matched) {
                        unmatchedCustomerCodes.add(customerCode); // 添加未匹配的客户编码
                    }
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 批量写入数据
        for (Map.Entry<File, List<Row>> entry : dataToWrite.entrySet()) {
            File caiwuFile = entry.getKey();
            List<Row> rowsToWrite = entry.getValue();
            writeDataToFile1(caiwuFile, rowsToWrite);
        }
        // 将未匹配的客户编码写入记事本
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(unmatchedLogFile, true))) {
            // 添加当前时间
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            String timestamp = LocalDateTime.now().format(formatter);
            writer.write("时间: " + timestamp);
            writer.newLine();
            for (String code : unmatchedCustomerCodes) {
                writer.write(code);
                writer.newLine();
            }
            System.out.println("未匹配的客户编码已写入文件: " + unmatchedLogPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
        System.out.println("--------------------------结束-------处理运费补收-----------------------------");
    }

    private static void writeDataToFile1(File caiwuFile, List<Row> rowsToWrite) {
        try (FileInputStream fis = new FileInputStream(caiwuFile);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(2);
            System.out.println("1111111111" + caiwuFile.getName());

            // 获取目标文件的第2行开始写入数据
//            int targetRowIndex = sheet.getPhysicalNumberOfRows();
//            if (targetRowIndex <= 1) {  // 如果数据不足第2行，设置为从第2行开始
//                targetRowIndex = 1;
//            }
            // 获取目标文件的第4行开始写入数据
            int targetRowIndex = 3;
            XSSFFont font = workbook.createFont();
            font.setFontName("等线");
            font.setFontHeightInPoints((short) 10);  // 设置字号为10
            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font);

            XSSFCellStyle numberCellStyle = workbook.createCellStyle();
            numberCellStyle.setFont(font);
            XSSFFont numFont = workbook.createFont();
            numFont.setFontName("等线");
            numFont.setFontHeightInPoints((short) 10);
            numberCellStyle.setFont(numFont);
            numberCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0.00"));

            XSSFCellStyle integerCellStyle = workbook.createCellStyle();
            integerCellStyle.setFont(font);
            integerCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0"));

            // 添加文本格式样式
            XSSFCellStyle textCellStyle = workbook.createCellStyle();
            textCellStyle.setFont(font);
            textCellStyle.setDataFormat(workbook.createDataFormat().getFormat("@"));  // 设置为文本格式

            // 批量写入数据
            for (Row row : rowsToWrite) {
                Row targetRow = sheet.createRow(targetRowIndex++);
                for (int i = 1; i < row.getLastCellNum(); i++) {
                    Cell sourceCell = row.getCell(i);
                    Cell targetCell = targetRow.createCell(i - 1);  // 写入时列索引左移1

                    if (i == 7 || (i >= 18 && i <= 38)) {
                        targetCell.setCellStyle(numberCellStyle);
                    } else {
                        targetCell.setCellStyle(cellStyle);
                    }

                    if (sourceCell != null && sourceCell.getCellType() != CellType.BLANK && !sourceCell.toString().trim().isEmpty()) {
                        if (i == 17) {
                            // 如果是公式，直接写入公式
                            if (sourceCell.getCellType() == CellType.FORMULA) {
                                targetCell.setCellFormula(sourceCell.getCellFormula());
                            }
                            // 如果是数字，按数字处理
                            else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                BigDecimal value = new BigDecimal(sourceCell.getNumericCellValue());
                                value = value.setScale(2, RoundingMode.HALF_UP);
                                targetCell.setCellValue(value.doubleValue());
                            }
                            // 其他情况
                            else {
                                targetCell.setCellValue(sourceCell.toString());
                            }
                        } else if ((i >= 7 && i <= 38)) {
                            if (sourceCell.getCellType() == CellType.STRING) {
                                BigDecimal value = new BigDecimal(sourceCell.getStringCellValue().trim());
                                value = value.setScale(2, RoundingMode.HALF_UP);
                                targetCell.setCellValue(value.doubleValue());
                            } else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                BigDecimal value = new BigDecimal(sourceCell.getNumericCellValue());
                                value = value.setScale(2, RoundingMode.HALF_UP);
                                targetCell.setCellValue(value.doubleValue());
                            } else {
                                targetCell.setCellValue(0);
                            }
                        } else if (i == 3 || i == 6) {
                            if (sourceCell.getCellType() == CellType.STRING) {
                                targetCell.setCellValue(sourceCell.getStringCellValue());
                            } else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                String stringValue = String.format("%.0f", sourceCell.getNumericCellValue());
                                targetCell.setCellValue(stringValue);
                            } else {
                                targetCell.setCellValue(""); // 空值时，设为默认空字符串
                            }
                        } else {
                            targetCell.setCellValue(sourceCell.toString());
                        }
                    } else {
                        targetCell.setCellValue("");
                    }
                }
            }

            workbook.setForceFormulaRecalculation(true);

            // 保存修改后的文件
            try (FileOutputStream fos = new FileOutputStream(caiwuFile)) {
                workbook.write(fos);  // 写入修改后的数据到文件
                System.out.println("数据已写入文件: " + caiwuFile.getName());
            }
        } catch (IOException | POIXMLException e) {
            // 打印错误信息以及出错文件的名称
            System.err.println("写入文件失败，客户文件: " + caiwuFile.getName());
            e.printStackTrace();  // 打印详细错误信息，特别是POIXMLException会提供关于文件结构的问题
        }
    }

    /**
     * 购买运单
     */
    @Override
    public void purchaseWaybill() {
        System.out.println("--------------------------开始-------处理购买运单-----------------------------");
        System.out.println(new Date());
//                String folderPath = "D:/caiwu/对账单";  // 文件夹路径
//        String sourceFolderPath = "D:/caiwu/购买运单";  // 文件夹路径
        String sourceFolderPath = "\\\\192.168.10.30\\共享\\购买运单";  // 源文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\对账单";  // 目标文件夹路径
        String unmatchedLogPath = "\\\\192.168.10.30\\共享\\未匹配客户\\购买运单未匹配客户编码.txt";  // 记录未匹配客户编码的路径

        // 获取源文件夹中的所有Excel文件
        File sourceFolder = new File(sourceFolderPath);
        File[] sourceFiles = sourceFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        // 创建记录未匹配客户编码的文件
        File unmatchedLogFile = new File(unmatchedLogPath);

        // 获取目标文件夹中的所有Excel文件
        File billFolder = new File(folderPath);
        File[] billFiles = billFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        // 为每个目标文件批量收集要写入的数据
        Map<File, List<Row>> dataToWrite = new HashMap<>();
        Set<String> unmatchedCustomerCodes = new HashSet<>(); // 用于存储未匹配的客户编码

        // 处理每个源文件
        for (File sourceFile : sourceFiles) {
            try (FileInputStream fis = new FileInputStream(sourceFile);
                 XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

                // 读取第一个Sheet
                Sheet sheet = workbook.getSheetAt(0);
                // 从第2行开始读取数据
                for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {
                    Row row = sheet.getRow(i);
                    if (row == null) continue;  // 跳过空行

                    // 获取第一列（客户编码）
                    Cell cell = row.getCell(0);
                    if (cell == null) continue;  // 如果最后一列为空，跳过当前行

                    String customerCode = cell.getStringCellValue().trim();
                    System.out.println("正在处理客户编码: " + customerCode);
                    boolean matched = false; // 标志是否匹配到目标文件

                    // 匹配目标文件夹中的文件
                    for (File caiwuFile : billFiles) {
                        String caiwuFileName = caiwuFile.getName();

                        // 排除包含“易仓”和“效合”的文件
                        if (caiwuFileName.contains("易仓") || caiwuFileName.contains("效合")) {
                            continue;
                        }

                        // 检查文件名的前四位是否匹配客户编码
                        if (caiwuFileName.substring(0, 4).equals(customerCode)) {
                            matched = true;
                            // 如果匹配，将数据添加到目标文件的列表中
                            dataToWrite
                                    .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                    .add(row);
                        }
                    }

                    if (!matched) {
                        unmatchedCustomerCodes.add(customerCode); // 添加未匹配的客户编码
                    }
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 批量写入数据
        for (Map.Entry<File, List<Row>> entry : dataToWrite.entrySet()) {
            File caiwuFile = entry.getKey();
            List<Row> rowsToWrite = entry.getValue();
            writeDataToFile2(caiwuFile, rowsToWrite);
        }
        // 将未匹配的客户编码写入记事本
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(unmatchedLogFile, true))) {
            // 添加当前时间
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            String timestamp = LocalDateTime.now().format(formatter);
            writer.write("时间: " + timestamp);
            writer.newLine();
            for (String code : unmatchedCustomerCodes) {
                writer.write(code);
                writer.newLine();
            }
            System.out.println("未匹配的客户编码已写入文件: " + unmatchedLogPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
        System.out.println("--------------------------结束-------处理购买运单-----------------------------");

    }

    private static void writeDataToFile2(File caiwuFile, List<Row> rowsToWrite) {
        try (FileInputStream fis = new FileInputStream(caiwuFile);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            // 获取目标文件的第4个Sheet（假设数据要写入第4个Sheet）
            Sheet sheet = workbook.getSheetAt(3);
            System.out.println("目标Sheet名称: " + sheet.getSheetName());

            // 获取目标文件的第2行开始写入数据
            int targetRowIndex = 1;

            // 创建字体对象，设置为等线（Microsoft JhengHei）10号
            XSSFFont font = workbook.createFont();
            font.setFontName("等线");
            font.setFontHeightInPoints((short) 10);  // 设置字号为10

            // 创建样式对象，应用字体
            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font);

            // 设置数字格式化规则，保留两位小数
            XSSFCellStyle numberCellStyle = workbook.createCellStyle();
            numberCellStyle.setFont(font);
            XSSFFont numFont = workbook.createFont();
            numFont.setFontName("等线");
            numFont.setFontHeightInPoints((short) 10);  // 设置字号为10
            numberCellStyle.setFont(numFont);
            numberCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0.00"));  // 保留两位小数

            // 设置整数格式化规则
            XSSFCellStyle integerCellStyle = workbook.createCellStyle();
            integerCellStyle.setFont(font);
            integerCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0"));  // 整数格式
            // 添加文本格式样式
            XSSFCellStyle textCellStyle = workbook.createCellStyle();
            textCellStyle.setFont(font);
            textCellStyle.setDataFormat(workbook.createDataFormat().getFormat("@"));  // 设置为文本格式
            //日期
            XSSFCellStyle dateTimeCellStyle = workbook.createCellStyle();
            dateTimeCellStyle.setFont(font);
            CreationHelper createHelper = workbook.getCreationHelper();
            dateTimeCellStyle.setDataFormat(createHelper.createDataFormat().getFormat("yyyy/MM/dd HH:mm:ss"));

            // 批量写入数据
            for (Row row : rowsToWrite) {
                // 获取目标行
                Row targetRow = sheet.createRow(targetRowIndex++);

                // 遍历每一列数据，
                // 遍历每一列数据
                for (int i = 1; i <= 7; i++) {
                    Cell sourceCell = row.getCell(i);
                    Cell targetCell = targetRow.createCell(i - 1); // 写入时列索引左移1

                    // 设置单元格样式
                    if (i == 5) { // 对应需要保留两位小数的列
                        targetCell.setCellStyle(numberCellStyle);
                    } else {
                        targetCell.setCellStyle(cellStyle);
                    }

                    if (sourceCell != null) {
                        if (i == 2) {
                            targetCell.setCellStyle(textCellStyle); // 设置为文本格式
                            if (sourceCell != null) {
                                if (sourceCell.getCellType() == CellType.STRING) {
                                    targetCell.setCellValue(sourceCell.getStringCellValue());
                                } else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                    // 将数字转为字符串，避免科学计数法
                                    String strVal = String.format("%.0f", sourceCell.getNumericCellValue());
                                    targetCell.setCellValue(strVal);
                                } else {
                                    targetCell.setCellValue(sourceCell.toString());  // 其他类型强转为字符串
                                }
                            } else {
                                targetCell.setCellValue(""); // 单元格为空时填空字符串
                            }
                        } else if (i == 5) {
                            try {
                                if (sourceCell.getCellType() == CellType.STRING) {
                                    // 尝试将字符串转为BigDecimal
                                    BigDecimal value = new BigDecimal(sourceCell.getStringCellValue().trim());
                                    value = value.setScale(2, RoundingMode.HALF_UP); // 保留两位小数
                                    targetCell.setCellValue(value.doubleValue());
                                } else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                    // 如果是数字，直接转为BigDecimal处理
                                    BigDecimal value = new BigDecimal(sourceCell.getNumericCellValue());
                                    value = value.setScale(2, RoundingMode.HALF_UP); // 保留两位小数
                                    targetCell.setCellValue(value.doubleValue());
                                } else {
                                    targetCell.setCellValue(0); // 非数字类型则置为0
                                }
                            } catch (Exception e) {
                                targetCell.setCellValue(0); // 异常处理：填充0
                            }
                        } else if (i == 6) {
                            if (sourceCell.getCellType() == CellType.STRING) {
                                targetCell.setCellValue(sourceCell.getStringCellValue());
                            } else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                // 将数字转换为字符串处理，避免科学计数法
                                String stringValue = String.format("%.0f", sourceCell.getNumericCellValue());
                                targetCell.setCellValue(stringValue);
                            } else {
                                targetCell.setCellValue(""); // 如果单元格为空，设置为默认空字符串
                            }
                        } else {
                            if (i == 4) {
                                targetCell.setCellValue(sourceCell.getDateCellValue());
                                targetCell.setCellStyle(dateTimeCellStyle);
                            } else {
                                // 对其他列，按原样复制
                                targetCell.setCellValue(sourceCell.toString());
                            }
                        }
                    } else {
                        // 如果单元格为空，设置为默认空字符串
                        targetCell.setCellValue("");
                    }
                }
            }
            // 强制重新计算所有公式
            workbook.setForceFormulaRecalculation(true);
            // 保存修改后的文件
            try (FileOutputStream fos = new FileOutputStream(caiwuFile)) {
                workbook.write(fos);  // 写入修改后的数据到文件
                System.out.println("数据已写入文件: " + caiwuFile.getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void wareHouse() {
        System.out.println("--------------------------开始-------处理仓储费-----------------------------");
//        System.out.println(new Date());
//        String sourceFolderPath = "D:/caiwu/仓储费";  // 文件夹路径
//        String folderPath = "D:/caiwu/对账单";  // 文件夹路径
        String sourceFolderPath = "\\\\192.168.10.30\\共享\\仓储费";  // 源文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\对账单";  // 目标文件夹路径
        String unmatchedLogPath = "\\\\192.168.10.30\\共享\\未匹配客户\\仓储费未匹配客户编码.txt";  // 记录未匹配客户编码的路径

        // 创建记录未匹配客户编码的文件
        File unmatchedLogFile = new File(unmatchedLogPath);
        // 获取源文件夹中的所有Excel文件
        File sourceFolder = new File(sourceFolderPath);
        File[] sourceFiles = sourceFolder.listFiles((dir, name) -> name.endsWith(".xls") || name.endsWith(".xlsx"));

        // 获取目标文件夹中的所有Excel文件
        File billFolder = new File(folderPath);
        File[] billFiles = billFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        // 为每个目标文件批量收集要写入的数据
        Map<File, List<Row>> dataToWrite = new HashMap<>();
        Set<String> unmatchedCustomerCodes = new HashSet<>(); // 用于存储未匹配的客户编码
        // 处理每个源文件
        for (File sourceFile : sourceFiles) {
            try (FileInputStream fis = new FileInputStream(sourceFile)) {
                Workbook workbook = null;

                // 判断文件扩展名，选择合适的 Workbook 类型
                if (sourceFile.getName().endsWith(".xlsx")) {
                    workbook = new XSSFWorkbook(fis);  // 适用于 .xlsx 文件
                } else if (sourceFile.getName().endsWith(".xls")) {
                    workbook = new HSSFWorkbook(fis);  // 适用于 .xls 文件
                }

                if (workbook != null) {
                    // 读取第一个Sheet
                    Sheet sheet = workbook.getSheetAt(0);

                    // 从第2行开始读取数据（索引从0开始，第二行的索引是1）
                    for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {
                        Row row = sheet.getRow(i);
                        if (row == null) continue;  // 跳过空行

                        // 获取客户编码所在的列（假设是最后列）
                        Cell cell = row.getCell(row.getLastCellNum() - 2);
                        if (cell == null) continue;  // 如果没有客户编码，跳过当前行

                        String customerCode = cell.getStringCellValue().trim();
                        System.out.println("正在处理客户编码: " + customerCode);
                        boolean matched = false; // 标志是否匹配到目标文件

                        // 匹配目标文件夹中的文件

                        //-----------------------------------------------
                        for (File caiwuFile : billFiles) {
                            String caiwuFileName = caiwuFile.getName();
                            // 排除包含“易仓”和“效合”的文件
                            if (caiwuFileName.contains("易仓") || caiwuFileName.contains("效合")) {
                                continue;
                            }
                            // 检查文件名的前四位是否匹配客户编码
                            if (caiwuFileName.substring(0, 4).equals(customerCode)) {
                                matched = true; // 标记已匹配
                                // 如果匹配，将数据添加到目标文件的列表中
                                dataToWrite
                                        .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                        .add(row);
                                break; // 跳出匹配循环
                            }
                        }

                        //-----------------------------------------------

                        if (!matched) {
                            unmatchedCustomerCodes.add(customerCode); // 添加未匹配的客户编码
                        }
                    }
                    workbook.close();  // 确保关闭工作簿
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 批量写入数据
        for (Map.Entry<File, List<Row>> entry : dataToWrite.entrySet()) {
            File caiwuFile = entry.getKey();
            List<Row> rowsToWrite = entry.getValue();
            writeDataToFile3(caiwuFile, rowsToWrite);
        }
        // 将未匹配的客户编码写入记事本
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(unmatchedLogFile, true))) {
            // 添加当前时间
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            String timestamp = LocalDateTime.now().format(formatter);
            writer.write("时间: " + timestamp);
            writer.newLine();
            for (String code : unmatchedCustomerCodes) {
                writer.write(code);
                writer.newLine();
            }
            System.out.println("未匹配的客户编码已写入文件: " + unmatchedLogPath);
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println(new Date());
        System.out.println("--------------------------结束-------处理仓储费-----------------------------");
    }

    private static void writeDataToFile3(File caiwuFile, List<Row> rowsToWrite) {
        try (FileInputStream fis = new FileInputStream(caiwuFile);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(6);
            System.out.println("目标Sheet名称: " + sheet.getSheetName());
            int targetRowIndex = 1;
            // 创建字体对象，设置为等线（Microsoft JhengHei）10号
            XSSFFont font = workbook.createFont();
            font.setFontName("等线");
            font.setFontHeightInPoints((short) 10);  // 设置字号为10

            // 创建样式对象，应用字体
            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font);

            // 设置数字格式化规则，保留两位小数
            XSSFCellStyle numberCellStyle = workbook.createCellStyle();
            numberCellStyle.setFont(font);
            XSSFFont numFont = workbook.createFont();
            numFont.setFontName("等线");
            numFont.setFontHeightInPoints((short) 10);  // 设置字号为10
            numberCellStyle.setFont(numFont);
            numberCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0.0000000000"));

            // 设置整数格式化规则
            XSSFCellStyle integerCellStyle = workbook.createCellStyle();
            integerCellStyle.setFont(font);
            integerCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0"));  // 整数格式
            //日期格式
            XSSFCellStyle dateCellStyle = workbook.createCellStyle();
            dateCellStyle.setFont(font);
            CreationHelper createHelper = workbook.getCreationHelper();
            dateCellStyle.setDataFormat(createHelper.createDataFormat().getFormat("yyyy/MM/dd"));
            // 批量写入数据
            for (Row row : rowsToWrite) {
                // 获取目标行
                Row targetRow = sheet.createRow(targetRowIndex++);

                // 遍历每一列数据
                for (int i = 0; i < row.getLastCellNum(); i++) { // 从索引1开始，跳过第0列
                    Cell sourceCell = row.getCell(i);
                    Cell targetCell = targetRow.createCell(i);

                    // 设置单元格样式
                    if (i == 4) { // 对应需要保留两位小数的列
                        targetCell.setCellStyle(numberCellStyle);
                    } else {
                        targetCell.setCellStyle(cellStyle);
                    }
                    if (sourceCell != null) {
                        if (i == 5 || i == 6) {
                            targetCell.setCellStyle(integerCellStyle); // 使用整数样式
                            if (sourceCell != null) {
                                if (sourceCell.getCellType() == CellType.STRING) {
                                    try {
                                        BigDecimal value = new BigDecimal(sourceCell.getStringCellValue().trim());
                                        targetCell.setCellValue(value.intValue()); // Convert to integer
                                    } catch (NumberFormatException e) {
                                        targetCell.setCellValue(0); // Handle invalid number format
                                    }
                                } else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                    BigDecimal value = new BigDecimal(sourceCell.getNumericCellValue());
                                    targetCell.setCellValue(value.intValue()); // Convert to integer
                                } else {
                                    targetCell.setCellValue(0); // Non-numeric types set to 0
                                }
                            }
                        } else if (i == 4 || i == 8) {
                            try {
                                if (sourceCell.getCellType() == CellType.STRING) {
                                    // 尝试将字符串转为BigDecimal
                                    BigDecimal value = new BigDecimal(sourceCell.getStringCellValue().trim());
                                    value = value.setScale(10, RoundingMode.HALF_UP); // 保留两位小数
                                    targetCell.setCellValue(value.doubleValue());
                                } else if (sourceCell.getCellType() == CellType.NUMERIC) {
                                    // 如果是数字，直接转为BigDecimal处理
                                    BigDecimal value = new BigDecimal(sourceCell.getNumericCellValue());
                                    value = value.setScale(10, RoundingMode.HALF_UP); // 保留两位小数
                                    targetCell.setCellValue(value.doubleValue());
                                } else {
                                    targetCell.setCellValue(0); // 非数字类型则置为0
                                }
                            } catch (Exception e) {
                                targetCell.setCellValue(0); // 异常处理：填充0
                            }
                        } else {
                            if (i == 1) {
                                // 处理日期列：如果是日期类型就按日期处理，否则按字符串处理
                                if (sourceCell.getCellType() == CellType.NUMERIC && DateUtil.isCellDateFormatted(sourceCell)) {
                                    // 如果是日期格式
                                    targetCell.setCellValue(sourceCell.getDateCellValue());
                                    targetCell.setCellStyle(dateCellStyle);
                                } else {
                                    // 如果是字符串或其他格式，直接写入字符串值
                                    targetCell.setCellValue(sourceCell.toString());
                                    targetCell.setCellStyle(cellStyle); // 使用普通样式而不是日期样式
                                }
                            } else {
                                targetCell.setCellValue(sourceCell.toString());
                            }
                        }
                    } else {
                        // 如果单元格为空，设置为默认空字符串
                        targetCell.setCellValue("");
                    }
                }
            }
            // 强制重新计算所有公式
            workbook.setForceFormulaRecalculation(true);
            // 保存修改后的文件
            try (FileOutputStream fos = new FileOutputStream(caiwuFile)) {
                workbook.write(fos);  // 写入修改后的数据到文件
                System.out.println("数据已写入文件: " + caiwuFile.getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void workOrder() {
        System.out.println("--------------------------开始-------处理操作工单-----------------------------");
        System.out.println(new Date());
//        String folderPath = "D:/caiwu/对账单";  // 文件夹路径
//        String[] sourceFolderPaths = {"D:/caiwu/操作工单", "D:/caiwu/拖柜费"};  // 源文件夹路径数组

        String folderPath = "\\\\192.168.10.30\\共享\\对账单";  // 目标文件夹路径
        String[] sourceFolderPaths = {"\\\\192.168.10.30\\共享\\操作工单", "\\\\192.168.10.30\\共享\\拖柜费"};  // 源文件夹路径数组
        String unmatchedLogPath = "\\\\192.168.10.30\\共享\\未匹配客户\\操作工单未匹配客户编码.txt";  // 记录未匹配客户编码的路径

        // 获取目标文件夹中的所有Excel文件
        File billFolder = new File(folderPath);
        File[] billFiles = billFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));

        // 创建记录未匹配客户编码的文件
        File unmatchedLogFile = new File(unmatchedLogPath);

        // 为每个目标文件批量收集要写入的数据
        Map<File, List<Row>> dataToWrite = new HashMap<>();
        Set<String> unmatchedCustomerCodes = new HashSet<>(); // 用于存储未匹配的客户编码

        // 遍历每个源文件夹
        for (String sourceFolderPath : sourceFolderPaths) {
            File sourceFolder = new File(sourceFolderPath);
            System.out.println("正在处理文件夹: " + sourceFolderPath);
            if (!sourceFolder.exists() || !sourceFolder.isDirectory()) {
                System.out.println("文件夹不存在或不是目录: " + sourceFolderPath);
                continue;
            }

            File[] sourceFiles = sourceFolder.listFiles((dir, name) -> name.endsWith(".xls") || name.endsWith(".xlsx"));

            if (sourceFiles != null && sourceFiles.length > 0) {
                // 处理每个源文件
                for (File sourceFile : sourceFiles) {
                    try (FileInputStream fis = new FileInputStream(sourceFile)) {
                        Workbook workbook = null;

                        // 判断文件扩展名，选择合适的 Workbook 类型
                        if (sourceFile.getName().endsWith(".xlsx")) {
                            workbook = new XSSFWorkbook(fis);  // 适用于 .xlsx 文件
                        } else if (sourceFile.getName().endsWith(".xls")) {
                            workbook = new HSSFWorkbook(fis);  // 适用于 .xls 文件
                        }

                        if (workbook != null) {
                            // 读取第一个Sheet
                            Sheet sheet = workbook.getSheetAt(0);

                            // 从第3行开始读取数据（索引从0开始，第二行的索引是1）
                            for (int i = 2; i < sheet.getPhysicalNumberOfRows(); i++) {
                                Row row = sheet.getRow(i);
                                if (row == null) continue;  // 跳过空行

                                // 获取客户编码所在的列（假设是最后列）
                                Cell cell = row.getCell(row.getLastCellNum() - 1);
                                if (cell == null) continue;  // 如果没有客户编码，跳过当前行

                                String customerCode = cell.getStringCellValue().trim();
                                System.out.println("正在处理客户编码: " + customerCode);
                                boolean matched = false; // 标志是否匹配到目标文件


                                // 匹配目标文件夹中的文件
                                if ("效合".equals(customerCode)) {
                                    // 如果客户编码是“效合”，匹配目标文件名包含“效合”的文件
                                    for (File caiwuFile : billFiles) {
                                        if (caiwuFile.getName().contains("效合")) {
                                            matched = true;
                                            dataToWrite
                                                    .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                                    .add(row);
                                        }
                                    }
                                } else {
                                    for (File caiwuFile : billFiles) {
                                        String caiwuFileName = caiwuFile.getName();

                                        // 排除包含“易仓”和“效合”的文件
                                        if (caiwuFileName.contains("易仓")) {
                                            continue;
                                        }

                                        // 检查文件名的前四位是否匹配客户编码
                                        if (caiwuFileName.substring(0, 4).equals(customerCode)) {
                                            // 如果匹配，将数据添加到目标文件的列表中
                                            matched = true;
                                            dataToWrite
                                                    .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                                    .add(row);
                                        }
                                    }
                                }
                                if (!matched) {
                                    unmatchedCustomerCodes.add(customerCode); // 添加未匹配的客户编码
                                }

                            }
                            workbook.close();  // 确保关闭工作簿
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                System.out.println("文件夹中没有符合条件的文件: " + sourceFolderPath);
            }
        }

        // 批量写入数据
        for (Map.Entry<File, List<Row>> entry : dataToWrite.entrySet()) {
            File caiwuFile = entry.getKey();
            List<Row> rowsToWrite = entry.getValue();
            writeDataToFile4(caiwuFile, rowsToWrite);
        }
        // 将未匹配的客户编码写入记事本
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(unmatchedLogFile, true))) {
            // 添加当前时间
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            String timestamp = LocalDateTime.now().format(formatter);
            writer.write("时间: " + timestamp);
            writer.newLine();
            for (String code : unmatchedCustomerCodes) {
                writer.write(code);
                writer.newLine();
            }
            System.out.println("未匹配的客户编码已写入文件: " + unmatchedLogPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
        System.out.println("--------------------------结束-------处理操作工单-----------------------------");


    }

    private static void writeDataToFile4(File caiwuFile, List<Row> sourceRows) {
        if (!caiwuFile.exists()) {
            System.err.println("❌ 文件不存在: " + caiwuFile.getAbsolutePath());
            return;
        }
        if (caiwuFile.length() == 0) {
            System.err.println("❌ 文件为空: " + caiwuFile.getAbsolutePath());
            return;
        }

        try (FileInputStream fis = new FileInputStream(caiwuFile);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(4);

            // 清理现有内容和批注（从第3行开始）
            int firstRowToClear = 2; // 第3行（0-based）
            int lastRow = sheet.getLastRowNum();

            // 删除所有行从第3行开始
            for (int i = firstRowToClear; i <= lastRow; i++) {
                Row row = sheet.getRow(i);
                if (row != null) {
                    // 先删除批注
                    for (Cell cell : row) {
                        if (cell.getCellComment() != null) {
                            cell.removeCellComment();
                        }
                    }
                    // 然后删除行
                    sheet.removeRow(row);
                }
            }

            // 创建样式和字体
            XSSFFont font = workbook.createFont();
            font.setFontName("等线");
            font.setFontHeightInPoints((short) 10);

            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font);

            XSSFCellStyle numberCellStyle = workbook.createCellStyle();
            numberCellStyle.setFont(font);
            numberCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0.00"));

            XSSFCellStyle dateCellStyle = workbook.createCellStyle();
            dateCellStyle.setFont(font);
            CreationHelper createHelper = workbook.getCreationHelper();
            dateCellStyle.setDataFormat(createHelper.createDataFormat().getFormat("yyyy/MM/dd"));

            Drawing<?> drawing = sheet.createDrawingPatriarch();
            int targetRowIndex = 2; // 从第3行开始写入

            // 处理每一行源数据
            for (Row sourceRow : sourceRows) {
                Row targetRow = sheet.createRow(targetRowIndex++);

                for (int i = 0; i < sourceRow.getLastCellNum() && i <= 53; i++) {
                    Cell sourceCell = sourceRow.getCell(i);
                    if (sourceCell == null) continue;

                    Cell targetCell = targetRow.createCell(i);

                    // 设置单元格样式
                    if (i >= 11 && i <= 53) {
                        targetCell.setCellStyle(numberCellStyle);
                    } else {
                        targetCell.setCellStyle(cellStyle);
                    }

                    // 处理单元格值
                    switch (sourceCell.getCellType()) {
                        case STRING:
                            if (i >= 5 && i <= 10 && "-".equals(sourceCell.getStringCellValue().trim())) {
                                targetCell.setCellValue("-");
                            } else if (i >= 11 && i <= 52 && i != 52 && i != 37) {
                                try {
                                    BigDecimal value = new BigDecimal(sourceCell.getStringCellValue().trim());
                                    targetCell.setCellValue(value.setScale(2, RoundingMode.HALF_UP).doubleValue());
                                } catch (NumberFormatException e) {
                                    targetCell.setCellValue(sourceCell.getStringCellValue());
                                }
                            } else {
                                targetCell.setCellValue(sourceCell.getStringCellValue());
                            }
                            break;
                        case NUMERIC:
                            if (i == 0) {
                                targetCell.setCellValue(sourceCell.getDateCellValue());
                                targetCell.setCellStyle(dateCellStyle);
                            } else if (i >= 11 && i <= 52 && i != 52 && i != 37) {
                                BigDecimal value = BigDecimal.valueOf(sourceCell.getNumericCellValue());
                                targetCell.setCellValue(value.setScale(2, RoundingMode.HALF_UP).doubleValue());
                            } else {
                                targetCell.setCellValue(sourceCell.getNumericCellValue());
                            }
                            break;
                        case FORMULA:
                            // 对于公式单元格，获取计算后的值
                            FormulaEvaluator evaluator = sourceRow.getSheet().getWorkbook().getCreationHelper().createFormulaEvaluator();
                            CellValue cellValue = evaluator.evaluate(sourceCell);

                            switch (cellValue.getCellType()) {
                                case NUMERIC:
                                    if (i >= 11 && i <= 52 && i != 52 && i != 37) {
                                        BigDecimal value = BigDecimal.valueOf(cellValue.getNumberValue());
                                        targetCell.setCellValue(value.setScale(2, RoundingMode.HALF_UP).doubleValue());
                                    } else {
                                        targetCell.setCellValue(cellValue.getNumberValue());
                                    }
                                    break;
                                case STRING:
                                    targetCell.setCellValue(cellValue.getStringValue());
                                    break;
                                default:
                                    targetCell.setCellValue("");
                            }
                            break;
                        case BLANK:
                            targetCell.setCellValue("");
                            break;
                        default:
                            targetCell.setCellValue("");
                    }

                    // 复制批注
                    if (sourceCell.getCellComment() != null) {
                        // 先删除已有批注（如果有）
                        if (targetCell.getCellComment() != null) {
                            targetCell.removeCellComment();
                        }
                        Comment sourceComment = sourceCell.getCellComment();
                        ClientAnchor anchor = createHelper.createClientAnchor();
                        anchor.setCol1(targetCell.getColumnIndex());
                        anchor.setCol2(targetCell.getColumnIndex() + 1);
                        anchor.setRow1(targetCell.getRowIndex());
                        anchor.setRow2(targetCell.getRowIndex() + 1);

                        Comment targetComment = drawing.createCellComment(anchor);
                        targetComment.setString(sourceComment.getString());
                        targetComment.setAuthor(sourceComment.getAuthor());
                        targetCell.setCellComment(targetComment);
                    }
                }
            }
            workbook.setForceFormulaRecalculation(true);

            // 保存文件
            try (FileOutputStream fos = new FileOutputStream(caiwuFile)) {
                workbook.write(fos);
                System.out.println("✅ 数据已成功写入文件: " + caiwuFile.getName());
            }
        } catch (IOException e) {
            System.err.println("❌ 写入文件失败: " + caiwuFile.getAbsolutePath());
            e.printStackTrace();
        }
    }

    @Override
    public void unloadCabinet() {
        System.out.println("--------------------------开始-------处理卸柜费-----------------------------");
        System.out.println(new Date());

//        String folderPath = "D:/caiwu/对账单";  // 文件夹路径
//        String sourceFolderPath = "D:/caiwu/卸柜费";  // 文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\对账单";  // 存放目标文件的文件夹路径
        String sourceFolderPath = "\\\\192.168.10.30\\共享\\卸柜费";  // 源Excel文件夹路径
        String unmatchedLogPath = "\\\\192.168.10.30\\共享\\未匹配客户\\卸柜费未匹配客户编码.txt";  // 记录未匹配客户编码的路径

        // 获取源文件夹中的所有Excel文件
        File sourceFolder = new File(sourceFolderPath);
        File[] sourceFiles = sourceFolder.listFiles((dir, name) -> name.endsWith(".xls") || name.endsWith(".xlsx"));

        // 创建记录未匹配客户编码的文件
        File unmatchedLogFile = new File(unmatchedLogPath);

        // 获取目标文件夹中的所有Excel文件
        File billFolder = new File(folderPath);
        File[] billFiles = billFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));
        // 为每个目标文件批量收集要写入的数据
        Map<File, List<Row>> dataToWrite = new HashMap<>();

        Set<String> unmatchedCustomerCodes = new HashSet<>(); // 用于存储未匹配的客户编码
        // 处理每个源文件
        for (File sourceFile : sourceFiles) {
            try (FileInputStream fis = new FileInputStream(sourceFile)) {
                Workbook workbook = null;

                // 判断文件扩展名，选择合适的 Workbook 类型
                if (sourceFile.getName().endsWith(".xlsx")) {
                    workbook = new XSSFWorkbook(fis);  // 适用于 .xlsx 文件
                } else if (sourceFile.getName().endsWith(".xls")) {
                    workbook = new HSSFWorkbook(fis);  // 适用于 .xls 文件
                }

                if (workbook != null) {
                    Sheet sheet = workbook.getSheetAt(1);

                    // 从第3行开始读取数据（索引从0开始，第二行的索引是1）
                    for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {
                        Row row = sheet.getRow(i);
                        if (row == null) continue;  // 跳过空行

                        // 获取客户编码所在的列（假设是最后列）
                        Cell cell = row.getCell(18);
                        if (cell == null) continue;  // 如果没有客户编码，跳过当前行

                        String customerCode = cell.getStringCellValue().trim();
                        System.out.println("正在处理客户编码: " + customerCode);
                        boolean matched = false; // 标志是否匹配到目标文件

                        // 匹配目标文件夹中的文件

                        for (File caiwuFile : billFiles) {
                            String caiwuFileName = caiwuFile.getName();

                            // 排除包含“易仓”和“效合”的文件
                            if (caiwuFileName.contains("易仓") || caiwuFileName.contains("效合")) {
                                continue;
                            }

                            // 检查文件名的前四位是否匹配客户编码
                            if (caiwuFileName.substring(0, 4).equals(customerCode)) {
                                // 如果匹配，将数据添加到目标文件的列表中
                                matched = true;
                                dataToWrite
                                        .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                        .add(row);
                            }
                        }

                        if (!matched) {
                            unmatchedCustomerCodes.add(customerCode); // 添加未匹配的客户编码
                        }
                    }
                    workbook.close();  // 确保关闭工作簿
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 批量写入数据
        for (Map.Entry<File, List<Row>> entry : dataToWrite.entrySet()) {
            File caiwuFile = entry.getKey();
            List<Row> rowsToWrite = entry.getValue();
            writeDataToFile5(caiwuFile, rowsToWrite);
        }
        // 将未匹配的客户编码写入记事本
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(unmatchedLogFile, true))) {
            // 添加当前时间
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            String timestamp = LocalDateTime.now().format(formatter);
            writer.write("时间: " + timestamp);
            writer.newLine();
            for (String code : unmatchedCustomerCodes) {
                writer.write(code);
                writer.newLine();
            }
            System.out.println("未匹配的客户编码已写入文件: " + unmatchedLogPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
        System.out.println("--------------------------结束-------处理卸柜费-----------------------------");


    }

    private static void writeDataToFile5(File caiwuFile, List<Row> rowsToWrite) {
        try (FileInputStream fis = new FileInputStream(caiwuFile);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(5);

            int targetRowIndex = 1;  // 从第2行开始写入

            // 创建字体和样式
            XSSFFont font = workbook.createFont();
            font.setFontName("等线");
            font.setFontHeightInPoints((short) 10);

            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font);

            XSSFCellStyle numberCellStyle = workbook.createCellStyle();
            numberCellStyle.setFont(font);
            numberCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0.00"));

            XSSFCellStyle integerCellStyle = workbook.createCellStyle();
            integerCellStyle.setFont(font);
            integerCellStyle.setDataFormat(workbook.createDataFormat().getFormat("0"));

            Drawing<?> drawing = sheet.createDrawingPatriarch();

            // 批量写入数据
            for (Row row : rowsToWrite) {
                Row targetRow = sheet.createRow(targetRowIndex++);

                for (int i = 0; i < 20; i++) {
                    Cell sourceCell = row.getCell(i);
                    Cell targetCell = targetRow.createCell(i);

                    // 设置单元格样式
                    if (i == 1 || i == 9 || i == 10 || i == 11 || i == 12 || i == 13 || i == 14) {
                        targetCell.setCellStyle(integerCellStyle);
                    } else if (i == 15 || i == 16) {
                        targetCell.setCellStyle(numberCellStyle);
                    } else {
                        targetCell.setCellStyle(cellStyle);
                    }

                    if (sourceCell != null) {
                        // 关键修改：处理公式单元格
                        if (sourceCell.getCellType() == CellType.FORMULA) {
                            // 获取公式计算后的值
                            switch (sourceCell.getCachedFormulaResultType()) {
                                case NUMERIC:
                                    double numericValue = sourceCell.getNumericCellValue();
                                    if (i == 15 || i == 16) {
                                        targetCell.setCellValue(new BigDecimal(numericValue).setScale(2, RoundingMode.HALF_UP).doubleValue());
                                    } else if (i == 1 || i == 9 || i == 10 || i == 11 || i == 12 || i == 13 || i == 14) {
                                        targetCell.setCellValue((long) numericValue);
                                    } else {
                                        targetCell.setCellValue(numericValue);
                                    }
                                    break;
                                case STRING:
                                    targetCell.setCellValue(sourceCell.getStringCellValue());
                                    break;
                                default:
                                    targetCell.setCellValue("");
                            }
                        }
                        // 处理非公式单元格
                        else {
                            if (i == 1 || i == 9 || i == 10 || i == 11 || i == 12 || i == 13 || i == 14) {
                                try {
                                    if (sourceCell.getCellType() == CellType.STRING) {
                                        targetCell.setCellValue(Long.parseLong(sourceCell.getStringCellValue().trim()));
                                    } else {
                                        targetCell.setCellValue((long) sourceCell.getNumericCellValue());
                                    }
                                } catch (Exception e) {
                                    targetCell.setCellValue(0);
                                }
                            } else if (i == 15 || i == 16) {
                                try {
                                    if (sourceCell.getCellType() == CellType.STRING) {
                                        targetCell.setCellValue(Double.parseDouble(sourceCell.getStringCellValue().trim()));
                                    } else {
                                        targetCell.setCellValue(sourceCell.getNumericCellValue());
                                    }
                                } catch (Exception e) {
                                    targetCell.setCellValue(0);
                                }
                            } else {
                                targetCell.setCellValue(sourceCell.toString());
                            }
                        }

                        // 复制批注
                        if (sourceCell.getCellComment() != null) {
                            Comment sourceComment = sourceCell.getCellComment();
                            CreationHelper factory = workbook.getCreationHelper();

                            ClientAnchor anchor = factory.createClientAnchor();
                            anchor.setCol1(targetCell.getColumnIndex());
                            anchor.setCol2(targetCell.getColumnIndex() + 1);
                            anchor.setRow1(targetCell.getRowIndex());
                            anchor.setRow2(targetCell.getRowIndex() + 1);

                            Comment targetComment = drawing.createCellComment(anchor);
                            targetComment.setString(sourceComment.getString());
                            targetComment.setAuthor(sourceComment.getAuthor());
                            targetCell.setCellComment(targetComment);
                        }
                    } else {
                        targetCell.setCellValue("");
                    }
                }
            }

            workbook.setForceFormulaRecalculation(true);
            try (FileOutputStream fos = new FileOutputStream(caiwuFile)) {
                workbook.write(fos);
                System.out.println("数据已写入文件: " + caiwuFile.getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void compensation() {
        System.out.println("--------------------------开始-------处理赔付-----------------------------");
        System.out.println(new Date());
//        String folderPath = "D:/caiwu/对账单";  // 文件夹路径
//        String sourceFolderPath = "D:/caiwu/赔付";  // 文件夹路径
        String folderPath = "\\\\192.168.10.30\\共享\\对账单";  // 存放目标文件的文件夹路径
        String sourceFolderPath = "\\\\192.168.10.30\\共享\\赔付";  // 源Excel文件夹路径
        System.out.println(new Date());

        // 获取源文件夹中的所有Excel文件.
        File sourceFolder = new File(sourceFolderPath);
        File[] sourceFiles = sourceFolder.listFiles((dir, name) -> name.endsWith(".xls") || name.endsWith(".xlsx"));

        // 获取目标文件夹中的所有Excel文件
        File billFolder = new File(folderPath);
        File[] billFiles = billFolder.listFiles((dir, name) -> name.endsWith(".xlsx"));
        // 为每个目标文件批量收集要写入的数据
        Map<File, List<Row>> dataToWrite = new HashMap<>();

        // 处理每个源文件
        for (File sourceFile : sourceFiles) {
            try (FileInputStream fis = new FileInputStream(sourceFile)) {
                Workbook workbook = null;

                // 判断文件扩展名，选择合适的 Workbook 类型
                if (sourceFile.getName().endsWith(".xlsx")) {
                    workbook = new XSSFWorkbook(fis);  // 适用于 .xlsx 文件
                } else if (sourceFile.getName().endsWith(".xls")) {
                    workbook = new HSSFWorkbook(fis);  // 适用于 .xls 文件
                }

                if (workbook != null) {
                    // 读取第一个Sheet
                    Sheet sheet = workbook.getSheetAt(0);

                    // 从第2行开始读取数据（索引从0开始，第二行的索引是1）
                    for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {
                        Row row = sheet.getRow(i);
                        if (row == null) continue;  // 跳过空行

                        // 获取客户编码所在的列（假设是最后列）
                        Cell cell = row.getCell(4);
                        if (cell == null) continue;  // 如果没有客户编码，跳过当前行

                        String customerCode = cell.getStringCellValue().trim();
                        System.out.println("正在处理客户编码: " + customerCode);

                        // 匹配目标文件夹中的文件
                        for (File caiwuFile : billFiles) {
                            String caiwuFileName = caiwuFile.getName();

                            // 排除包含“易仓”和“效合”的文件
                            if (caiwuFileName.contains("易仓") || caiwuFileName.contains("效合")) {
                                continue;
                            }

                            // 检查文件名的前四位是否匹配客户编码
                            if (caiwuFileName.substring(0, 4).equals(customerCode)) {
                                // 如果匹配，将数据添加到目标文件的列表中
                                dataToWrite
                                        .computeIfAbsent(caiwuFile, k -> new ArrayList<>())
                                        .add(row);
                            }
                        }
                    }

                    workbook.close();  // 确保关闭工作簿
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 批量写入数据
        for (Map.Entry<File, List<Row>> entry : dataToWrite.entrySet()) {
            File caiwuFile = entry.getKey();
            List<Row> rowsToWrite = entry.getValue();
            writeDataToFile6(caiwuFile, rowsToWrite);
        }
        System.out.println(new Date());
        System.out.println("--------------------------结束-------处理赔付-----------------------------");
    }

    private static void writeDataToFile6(File caiwuFile, List<Row> rowsToWrite) {
        try (FileInputStream fis = new FileInputStream(caiwuFile);
             XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(0);

            // 先获取D列原有的宽度（单位是1/256个字符宽度）
            int originalColumnWidth = sheet.getColumnWidth(3); // D列索引是3

            // 获取目标文件的第27行开始写入数据
            int targetRowIndex = 26;

            // 1. 首先创建基础字体
            XSSFFont font = workbook.createFont();
            font.setFontName("等线");
            font.setFontHeightInPoints((short) 10);

            // 2. 创建通用边框样式（borderStyle）
            XSSFCellStyle borderStyle = workbook.createCellStyle();
            borderStyle.setFont(font);
            borderStyle.setBorderTop(BorderStyle.THIN);
            borderStyle.setBorderBottom(BorderStyle.THIN);
            borderStyle.setBorderLeft(BorderStyle.THIN);
            borderStyle.setBorderRight(BorderStyle.THIN);
            borderStyle.setAlignment(HorizontalAlignment.CENTER);
            borderStyle.setVerticalAlignment(VerticalAlignment.CENTER);

            // 3. 创建货币样式
            XSSFCellStyle currencyCellStyle = workbook.createCellStyle();
            currencyCellStyle.setFont(font);
            currencyCellStyle.setDataFormat(workbook.createDataFormat().getFormat("$0.00"));
            currencyCellStyle.setBorderTop(BorderStyle.THIN);
            currencyCellStyle.setBorderBottom(BorderStyle.THIN);
            currencyCellStyle.setBorderLeft(BorderStyle.THIN);
            currencyCellStyle.setBorderRight(BorderStyle.THIN);
            currencyCellStyle.setAlignment(HorizontalAlignment.RIGHT);
            currencyCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);

            // 4. 创建日期样式
            XSSFCellStyle dateCellStyle = workbook.createCellStyle();
            dateCellStyle.setFont(font);
            CreationHelper createHelper = workbook.getCreationHelper();
            dateCellStyle.setDataFormat(createHelper.createDataFormat().getFormat("yyyy/MM/dd"));
            dateCellStyle.setAlignment(HorizontalAlignment.CENTER);
            dateCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
            dateCellStyle.setBorderTop(BorderStyle.THIN);
            dateCellStyle.setBorderBottom(BorderStyle.THIN);
            dateCellStyle.setBorderLeft(BorderStyle.THIN);
            dateCellStyle.setBorderRight(BorderStyle.THIN);

            // 5. 创建自动换行样式（专门用于D列超过25个字符的情况）
            XSSFCellStyle wrapTextStyle = workbook.createCellStyle();
            wrapTextStyle.setFont(font);
            wrapTextStyle.setWrapText(true);
            wrapTextStyle.setBorderTop(BorderStyle.THIN);      // 上边框：细线
            wrapTextStyle.setBorderBottom(BorderStyle.THIN);   // 下边框：细线
            wrapTextStyle.setBorderLeft(BorderStyle.THIN);     // 左边框：细线
            wrapTextStyle.setBorderRight(BorderStyle.MEDIUM);  // 右边框：中等粗细（第二粗）
            wrapTextStyle.setVerticalAlignment(VerticalAlignment.CENTER); // 改为垂直居中
            wrapTextStyle.setAlignment(HorizontalAlignment.CENTER);

            XSSFCellStyle borderStyle1 = workbook.createCellStyle();
            borderStyle1.setFont(font);
            borderStyle1.setBorderTop(BorderStyle.THIN);
            borderStyle1.setBorderBottom(BorderStyle.THIN);
            borderStyle1.setBorderLeft(BorderStyle.THIN);
            borderStyle1.setBorderRight(BorderStyle.MEDIUM);
            borderStyle1.setAlignment(HorizontalAlignment.CENTER);
            borderStyle1.setVerticalAlignment(VerticalAlignment.CENTER);

            // 批量写入数据
            for (Row row : rowsToWrite) {
                Row targetRow = sheet.createRow(targetRowIndex++);
                targetRow.setHeightInPoints(26);  // 设置基础行高

                for (int i = 0; i < 5; i++) {
                    if (i == 4) continue;  // 跳过客户编码列

                    Cell sourceCell = row.getCell(i);
                    Cell targetCell = targetRow.createCell(i);

                    if (sourceCell != null) {
                        if (i == 2) {
                            // 货币列处理
                            if (sourceCell.getCellType() == CellType.NUMERIC) {
                                targetCell.setCellValue(sourceCell.getNumericCellValue());
                            } else {
                                targetCell.setCellValue(Double.parseDouble(sourceCell.toString()));
                            }
                            targetCell.setCellStyle(currencyCellStyle);
                        } else if (i == 0) {
                            // 日期列处理
                            targetCell.setCellValue(sourceCell.getDateCellValue());
                            targetCell.setCellStyle(dateCellStyle);
                        } else {
                            targetCell.setCellValue(sourceCell.toString());
                            // 专门处理D列（索引3）
                            if (i == 3) {
                                String cellValue = sourceCell.toString();
                                if (cellValue.length() > 25) {
                                    // 超过25个字符，使用换行样式
                                    targetCell.setCellStyle(wrapTextStyle);
                                    // 根据内容调整行高（每30个字符增加一行高度）
                                    int lineCount = (int) Math.ceil(cellValue.length() / 30.0);
                                    if (lineCount > 1) {
                                        targetRow.setHeightInPoints(26 + (lineCount - 1) * 12);
                                    }
                                } else {
                                    // 不超过25个字符
                                    targetCell.setCellStyle(borderStyle1);
                                }
                            } else {
                                targetCell.setCellStyle(borderStyle);
                            }
                        }
                    }
                }
            }

            // 恢复D列原有宽度
            sheet.setColumnWidth(3, originalColumnWidth);

            // 更新D25单元格的求和公式
            Row formulaRow = sheet.getRow(24);  // D25是第25行，索引是24
            if (formulaRow != null) {
                Cell formulaCell = formulaRow.getCell(3);  // D列索引是3
                if (formulaCell == null) {
                    formulaCell = formulaRow.createCell(3);
                }
                int lastRowIndex = sheet.getLastRowNum();
                String formula = "SUM(D5:D24, C27:C" + lastRowIndex + ")";
                formulaCell.setCellFormula(formula);
                System.out.println("更新了D25单元格的公式: " + formula);
            }

            // 强制重新计算所有公式
            workbook.setForceFormulaRecalculation(true);

            // 保存修改后的文件
            try (FileOutputStream fos = new FileOutputStream(caiwuFile)) {
                workbook.write(fos);
                System.out.println("数据已写入文件: " + caiwuFile.getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 汇总仓储费用
     */
    @Override
    public void summaryStorage() {
        String folderPath = "\\\\192.168.10.30\\共享\\仓储费";  // 存放目标文件的文件夹路径
        //String folderPath = "D:/caiwu/仓储费";  // 文件夹路径
        File folder = new File(folderPath);
        File[] files = folder.listFiles((dir, name) -> name.endsWith(".xls") || name.endsWith(".xlsx"));

        if (files == null || files.length == 0) {
            System.out.println("没有找到Excel文件");
            return;
        }

        // 创建一个新的工作簿用于汇总
        Workbook summaryWorkbook = new XSSFWorkbook();
        Sheet summarySheet = summaryWorkbook.createSheet("汇总仓储费用");
        int rowNum = 0;

        // 创建字体，设置为等线，字号为10
        Font font = summaryWorkbook.createFont();
        font.setFontName("等线");  // 设置字体为等线
        font.setFontHeightInPoints((short) 10);  // 设置字号为10

        // 创建一个样式，将字体应用到样式
        CellStyle cellStyle = summaryWorkbook.createCellStyle();
        cellStyle.setFont(font);  // 设置单元格的字体为等线

        // 标志位，确保只插入一个标题行
        boolean isFirstFile = true;

        // 遍历所有文件
        for (File file : files) {
            try (FileInputStream fis = new FileInputStream(file)) {
                Workbook workbook = WorkbookFactory.create(fis);
                Sheet sheet = workbook.getSheetAt(0);  // 获取第一个工作表

                // 如果是第一个文件，插入标题行
                if (isFirstFile) {
                    Row headerRow = summarySheet.createRow(rowNum++);
                    Row firstRow = sheet.getRow(0);  // 获取第一个文件的标题行
                    if (firstRow != null) {
                        for (int j = 0; j < firstRow.getPhysicalNumberOfCells(); j++) {
                            Cell headerCell = headerRow.createCell(j);
                            headerCell.setCellValue(firstRow.getCell(j).toString());  // 将标题复制到汇总表
                            headerCell.setCellStyle(cellStyle);  // 应用字体样式
                        }
                    }
                    isFirstFile = false;  // 设置标志位，确保只在第一次添加标题
                }

                // 从第二行开始插入数据行
                for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {  // 从第2行开始，跳过标题
                    Row row = sheet.getRow(i);
                    if (row != null) {
                        Row summaryRow = summarySheet.createRow(rowNum++);
                        for (int j = 0; j < row.getLastCellNum(); j++) {
                            Cell cell = row.getCell(j);
                            Cell summaryCell = summaryRow.createCell(j);

                            // 根据单元格的类型设置值
                            if (cell != null) {
                                // 根据单元格的类型设置值
                                switch (cell.getCellType()) {
                                    case NUMERIC:
                                        if (DateUtil.isCellDateFormatted(cell)) {
                                            summaryCell.setCellValue(cell.getDateCellValue());  // 处理日期类型
                                        } else {
                                            summaryCell.setCellValue(cell.getNumericCellValue());  // 处理数值类型
                                        }
                                        break;
                                    case STRING:
                                        summaryCell.setCellValue(cell.getStringCellValue());  // 处理字符串类型
                                        break;
                                    case BOOLEAN:
                                        summaryCell.setCellValue(cell.getBooleanCellValue());  // 处理布尔类型
                                        break;
                                    case FORMULA:
                                        summaryCell.setCellValue(cell.getCellFormula());  // 处理公式类型
                                        break;
                                    case ERROR:
                                        summaryCell.setCellValue(cell.getErrorCellValue());  // 处理错误类型
                                        break;
                                    default:
                                        summaryCell.setCellValue("");  // 处理默认情况（例如空单元格）
                                        break;
                                }
                            } else {
                                // 如果cell是null，也可以选择直接给summaryCell一个空值
                                summaryRow.createCell(j + 1);  // 创建一个空单元格
                            }

                            // 设置字体样式
                            summaryCell.setCellStyle(cellStyle);
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 写入汇总文件
        try (FileOutputStream fos = new FileOutputStream("\\\\192.168.10.30\\共享\\仓储费\\汇总仓储费用.xlsx")) {
            summaryWorkbook.write(fos);
            System.out.println("汇总文件已成功创建！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 汇总运费补收
     */
    @Override
    public void summaryCosts() {
        String folderPath = "\\\\192.168.10.30\\共享\\运费补收";  // 存放目标文件的文件夹路径
        //String folderPath = "D:/caiwu/运费补收";  // 文件夹路径
        File folder = new File(folderPath);
        File[] files = folder.listFiles((dir, name) -> name.endsWith(".xls") || name.endsWith(".xlsx"));

        if (files == null || files.length == 0) {
            System.out.println("没有找到Excel文件");
            return;
        }

        // 创建一个新的工作簿用于汇总
        Workbook summaryWorkbook = new XSSFWorkbook();
        Sheet summarySheet = summaryWorkbook.createSheet("汇总仓储费用");
        int rowNum = 0;

// 标志位，确保只插入一个标题行
        boolean isFirstFile = true;

// 创建一个样式，避免显示为科学计数法
        CellStyle cellStyle = summaryWorkbook.createCellStyle();
        DataFormat dataFormat = summaryWorkbook.createDataFormat();
        cellStyle.setDataFormat(dataFormat.getFormat("0"));  // 设置数字格式为常规数字

// 创建字体，设置为等线（Courier New）并且字体大小为10
        Font font = summaryWorkbook.createFont();
        font.setFontName("等线");  // 设置字体为等线
        font.setFontHeightInPoints((short) 10);  // 设置字体大小为10

// 将字体应用到单元格样式中
        cellStyle.setFont(font);

// 遍历所有文件
        for (File file : files) {
            String fileName = file.getName();
            String customerCode = fileName.length() >= 4 ? fileName.substring(fileName.length() - 8).substring(0, 4) : "";  // 获取文件名最后四位作为客户编码

            try (FileInputStream fis = new FileInputStream(file)) {
                Workbook workbook = WorkbookFactory.create(fis);
                Sheet sheet = workbook.getSheetAt(0);  // 获取第一个工作表

                // 如果是第一个文件，插入标题行
                if (isFirstFile) {
                    Row headerRow = summarySheet.createRow(rowNum++);
                    Row firstRow = sheet.getRow(0);  // 获取第一个文件的标题行
                    if (firstRow != null) {
                        // 插入客户编码列标题
                        Cell headerCell = headerRow.createCell(0);
                        headerCell.setCellValue("客户编码");
                        // 将标题复制到汇总表（从第二列开始）
                        for (int j = 0; j < firstRow.getPhysicalNumberOfCells(); j++) {
                            Cell headerCell2 = headerRow.createCell(j + 1);
                            headerCell2.setCellValue(firstRow.getCell(j).toString());  // 将标题复制到汇总表
                        }
                    }
                    isFirstFile = false;  // 设置标志位，确保只在第一次添加标题
                }

                // 从第二行开始插入数据行
                for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {  // 从第2行开始，跳过标题
                    Row row = sheet.getRow(i);
                    if (row != null) {
                        Row summaryRow = summarySheet.createRow(rowNum++);
                        // 在每一行的最前面插入客户编码
                        Cell summaryCustomerCodeCell = summaryRow.createCell(0);
                        summaryCustomerCodeCell.setCellValue(customerCode);

                        for (int j = 0; j < row.getLastCellNum(); j++) {
                            Cell cell = row.getCell(j);
                            if (cell != null) {
                                Cell summaryCell = summaryRow.createCell(j + 1);

                                // 根据单元格的类型设置值
                                switch (cell.getCellType()) {
                                    case NUMERIC:
                                        if (DateUtil.isCellDateFormatted(cell)) {
                                            summaryCell.setCellValue(cell.getDateCellValue());  // 处理日期类型
                                        } else {
                                            // 如果是第二列，应用数值格式
                                            if (j == 1) {
                                                summaryCell.setCellValue(cell.getNumericCellValue());
                                                summaryCell.setCellStyle(cellStyle);  // 应用数字格式
                                            } else {
                                                summaryCell.setCellValue(cell.getNumericCellValue());  // 处理数值类型
                                            }
                                        }
                                        break;
                                    case STRING:
                                        summaryCell.setCellValue(cell.getStringCellValue());  // 处理字符串类型
                                        break;
                                    case BOOLEAN:
                                        summaryCell.setCellValue(cell.getBooleanCellValue());  // 处理布尔类型
                                        break;
                                    case FORMULA:
                                        summaryCell.setCellValue(cell.getCellFormula());  // 处理公式类型
                                        break;
                                    case ERROR:
                                        summaryCell.setCellValue(cell.getErrorCellValue());  // 处理错误类型
                                        break;
                                    default:
                                        summaryCell.setCellValue("");  // 处理默认情况（例如空单元格）
                                        break;
                                }
                                summaryCell.setCellStyle(cellStyle);  // 设置字体样式
                            } else {
                                // 如果cell是null，也可以选择直接给summaryCell一个空值
                                summaryRow.createCell(j + 1);  // 创建一个空单元格
                            }
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 写入汇总文件
        try (FileOutputStream fos = new FileOutputStream("\\\\192.168.10.30\\共享\\运费补收\\汇总运费补收.xlsx")) {
            //try (FileOutputStream fos = new FileOutputStream("D:/caiwu/运费补收/汇总运费补收.xlsx")) {
            summaryWorkbook.write(fos);
            System.out.println("汇总文件已成功创建！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void deletePrevious() {
        //File folder = new File("D:/caiwu/对账单"); // 指定文件夹路径
        File folder = new File("\\\\192.168.10.30\\共享\\对账单"); // 指定文件夹路径
        File[] files = folder.listFiles((dir, name) -> name.endsWith(".xlsx") && !name.contains("易仓"));
        if (files == null || files.length == 0) {
            System.out.println("未找到符合条件的 Excel 文件");
            return;
        }

        for (File file : files) {
            try (FileInputStream fis = new FileInputStream(file);
                 XSSFWorkbook workbook = new XSSFWorkbook(fis)) {

                int sheetCount = workbook.getNumberOfSheets();
                for (int i = 0; i < sheetCount; i++) {
                    XSSFSheet sheet = workbook.getSheetAt(i);
                    if (sheet == null) continue;

                    // 删除所有图片
                    removePictures(sheet);

                    // 特殊处理“效合”文件
                    if (file.getName().contains("效合")) {
                        if (i == 4) { // 只处理第五个 sheet（索引从 0 开始）
                            deleteRowsFrom(sheet, 2); // 从第3行开始清空
                        }
                        continue; // 不处理其他 sheet
                    }

                    // 确定需要删除的行号
                    if (sheetCount > 4) {
                        if (i == 1 || i == 4) { // 第二个和第五个 sheet
                            deleteRowsFrom(sheet, 2);
                        } else if (i == 3 || i == 5 || i == 6) { // 第三、四、六、七个 sheet
                            deleteRowsFrom(sheet, 1);
                        } else if (i == 2) {
                            deleteRowsFrom(sheet, 3);
                        }
                    } else {
                        if (i == 1 || i == 3) { // 第二、四个 sheet
                            deleteRowsFrom(sheet, 2);
                        } else if (i == 2) { // 第三个 sheet
                            deleteRowsFrom(sheet, 1);
                        }
                    }
                    if (i == 0) {
                        clearRowsFromTwentySeven(sheet);
                    }
                }
// 强制 Excel 下次打开时重新计算所有公式
                workbook.setForceFormulaRecalculation(true);
                // 保存修改
                try (FileOutputStream fos = new FileOutputStream(file)) {
                    workbook.write(fos);
                }

                System.out.println("处理完成：" + file.getName());

            } catch (Exception e) {
                System.err.println("处理文件失败：" + file.getName());
                e.printStackTrace();
            }
        }
    }

    /**
     * 删除所有图片
     */
    private static void removePictures(XSSFSheet sheet) {
        XSSFDrawing drawing = sheet.getDrawingPatriarch();
        if (drawing != null) {
            drawing.getCTDrawing().getTwoCellAnchorList().clear();
        }
    }

    /**
     * 从 startRow 开始，清空所有数据并清除批注
     *
     * @param startRow 起始行（0 基）
     */
    private static void deleteRowsFrom(XSSFSheet sheet, int startRow) {
        int lastRowNum = sheet.getLastRowNum();
        for (int i = startRow; i <= lastRowNum; i++) {
            Row row = sheet.getRow(i);
            if (row != null) {
                clearComments(row);
                for (Cell cell : row) {
                    cell.setBlank(); // 清空内容
                }
            }
        }
    }

    /**
     * 清空第一个 sheet 从第 27 行开始的内容
     */
    private static void clearRowsFromTwentySeven(XSSFSheet sheet) {
        int lastRowNum = sheet.getLastRowNum();
        for (int i = 26; i <= lastRowNum; i++) { // Excel 行索引从 0 开始，第 27 行索引是 26
            Row row = sheet.getRow(i);
            if (row != null) {
                clearComments(row);
                for (Cell cell : row) {
                    cell.setBlank();
                }
            }
        }
    }

    /**
     * 清除某一行的所有单元格批注
     */
    private static void clearComments(Row row) {
        if (row == null) return;
        short lastCell = row.getLastCellNum();
        if (lastCell < 0) return;
        for (int c = 0; c < lastCell; c++) {
            Cell cell = row.getCell(c);
            if (cell != null && cell.getCellComment() != null) {
                cell.removeCellComment();
            }
        }
    }


    @Override
    public void test() throws FileNotFoundException {
        String folderPath = "D:/caiwu/对账单";
        File folder = new File(folderPath);

        File[] files = folder.listFiles((dir, name) -> name.endsWith(".xlsx") && !name.startsWith("~$"));

        if (files == null || files.length == 0) {
            System.out.println("未找到 Excel 文件");
            return;
        }

        for (File file : files) {
            try (FileInputStream fis = new FileInputStream(file);
                 Workbook wb = new XSSFWorkbook(fis)) {

                int sheetCount = wb.getNumberOfSheets();
                if (sheetCount < 7) {
                    System.out.println("Sheet 数量小于 7 的文件: " + file.getName() + " (Sheet 数量: " + sheetCount + ")");
                }

            } catch (Exception e) {
                System.out.println("无法读取文件: " + file.getName() + " → " + e.getMessage());
            }
        }
    }
}






